Also gebe ich mal meinen Senf dazu (in der Hoffnung, das ich alles richtig verstanden habe):
Generell ist es üblich, Code zu schreiben, der dann fix ist. Sprich: Du schreibst diverse Klassen und die werden dann kompiliert zu etwas, das irgendwie ausführbar ist.
==> Die Software erweitert sich also selbst nicht!
Die Software kann aber dann mit Daten arbeiten. Als Beispiel kann man hier z.B. Office nehmen: Du kannst Office starten und damit dann Daten verändern. Aber das Office selbst veränderst Du dabei nicht.
Natürlich kann es dann noch die Möglichkeit geben, AddOns / Plugins einzubauen, d.h. Deine Software bekommt die Möglichkeit, dass diese erweitert werden kann. Dies macht aber nur dann Sinn, wenn dies Dritte machen. Du kannst ja Deine Software direkt anpassen.
Und so wie es nun schon angeklungen ist: Mach Dir keine Gedanken darüber, wie es später aussehen soll oder mit welchen Elementen Du was darstellen willst. Mach Dir erst einmal Gedanken darüber, was die Software machen soll, was für Daten sollen eingegeben werden? Was für Daten müssen wie verarbeitet werden?
Wenn man die Daten klar definieren kann, dann ist es einfach. Dann kann ich eine Klasse schreiben, die z.B. Person heisst und die dann an Daten bestimmte Werte vorhält, z.B. Name, Geburtstag, Geburtsort.
Aber immer gut drüber nachdenken und dies genau verifizieren! So ist hier z.B. schon Adresse genannt worden. Aber hat jeder Person eine Adresse? Evtl. gibt es Obdachlose (keine Adresse) oder Menschen mit mehreren Adressen? Also muss eine Person keine, eine oder mehrere Adressen speichern können (also z.B. eine Liste mit Adressen).
Wenn man - so habe ich Dich verstanden - zur Entwicklungszeit die Felder nicht festlegen möchte oder kann, sondern der Anwender diese frei definieren können soll, dann erweitert sich das alles etwas.
Dann gibt es die Möglichkeit, PersonenAttribute festzulegen. Also kann man dann z.B. neue Attribute für Personen festlegen. Also z.B. Attribute wie "JavaForumLogin" oder so. Und dann hat eine Person neben Name, Geburtstag und Geburtsort noch eine Liste von PersonenAttributeMitWerten. Dieses PersonenAttributeMitWerten speichert also ein PersonenAttribut und einen Wert.
(Das ist erst einmal vereinfacht dargestellt. Das geht dann natürlich auch noch weiter, also z.B. kann ein PersonenAttribute noch viele Dinge haben wie ein Typ, eine Validierung, eine Formatierung, .... Also es kann z.B. eine Fließkommazahl sein, die aber zwischen 10000 und 10000000 sein muss und die mit . bei Tausendern und mit zwei Nachkommastellen angezeigt wird, z.B. 1.234.567,89.)
Und wenn man es dann noch generischer haben wollte, dann hätte man ein System, in dem man gar keine Person mehr hat, sondern man kann beliebige Entities (Nenne ich mal Tabelle) anlegen, mit beliebigen Werten (Feldern, Columns). Diese Entities können Beziehungen untereinander haben (Könnte man Foreign Keys nennen) und vielleicht bauen wir eine strukturierte Abfragesprache (Könnte man Structured Query Language, kurz SQL nennen)......
==> Du hast vielleicht schon erkannt, dass ich dann hier am Ende eine relationale Datenbank beschrieben habe.
Da Du aber gerade mal anfängst, möchte ich Dir ein paar Anregungen geben:
Fange ganz einfach an:
- Also schreib eine Klasse Person, in der Du erst einmal ein paar einfache Attribute speicherst.
- Dann schreibe erst einmal Code, mit dem Du mehrere Personen verwalten kannst, also Personen hinzufügen, Personen suchen, Personen entfernen
- Dann beschäftige Dich mit dem Laden und Speichern. Hier würde ich Dir aber durchaus empfehlen, Dich mit Datenbanken zu beschäftigen. Erfahrungsgemäß gibt es schnell mal Probleme mit einfachen Textfiles - spätestens wenn User Dinge eingeben, die so nicht vorgesehen waren ...
==> Dabei schreibst Du noch keine GUI! Das sind kleine Programme, die diese Funktionalität nutzen und bei denen Du dann am Ende prüfst, dass alles funktioniert. Also eine Datei mit test<WasWirdGetestet>() welche dann von main() aufgerufen wird. (Evtl. findest du ja etwas Zeit, in Unit Tests einzusteigen. JUnit ist nicht so komplex. Aber diese Methodik geht auch. Wichtig ist: Alle test-Funktionen rufst Du weiter auf. Wenn die Datei zu gross werden sollte, dann schieb die test-Funktionen in unterschiedliche Klassen / Dateien. Dann ruft main() halt sowas wie TestPerson.testLoadOfPersonen() auf oder so. (Du hast hier schon ein Unit-Test "light"!)
Wenn Du das hast, dann kannst Du der Person ja Attribute verpassen, die 1:n sind, also z.B. Adressen. Dann hat eine Person eine Liste von Adressen. Und Du musst Dir überlegen, wie Du diese dann verwalten kannst. Also wichtig ist, dass die Tests dann auch das hinzufügen, suchen und löschen von Adressen umfassen muss. Das Laden und Speichern muss dann auch erweitert werden.
Und bei einer Klasse wie Person willst Du evtl. dann ja auch equals überschreiben (und dann auch den hash code) und das sollte dann auch getestet werden. Und ein typischer Test kann dann z.B. sein, dass Du eine Person erzeugst, diese speicherst, dann wieder lädst und dann prüfst, dass die beiden Objekte und deren Hashcode gleich sind. Oder wenn du ein Attribut der Person veränderst, dann sind diese nicht mehr gleich.
So baust du ganz unspektakulär Code auf, mit dem Du Deine Daten verarbeiten kannst. Und Du hast Code, mit dem Du Testen kannst, ob alles funktioniert. An der Stelle kann man sich dann Gedanken machen, wie das denn dann aussehen kann: Soll es eine Applikation sind, die der Anwender so starten kann? Soll es eine Web Applikation werden? Was sind hier die Anforderungen?
An der Stelle breche ich aber jetzt erst einmal ab. Vielleicht hat es Dir ja etwas geholfen.
Viele Grüße,
Konrad
