Du verwendest einen veralteten Browser. Es ist möglich, dass diese oder andere Websites nicht korrekt angezeigt werden. Du solltest ein Upgrade durchführen oder ein alternativer Browser verwenden.
ich habe eine frage zur implementierung einer messklasse.
diese mess-klasse besitzt referenzen zu messklasse-header (nur für headerinformationen), messklasse-data (nur für die datenmanipulation) und messklasse-jTable (ansicht in gui). daneben gibt 2 klassen importMessung (einlesen eines mess-import-files in eine db) und exportMessung (auslesen aus db in ein export-file) jeweils abgeleitet von File. wie könnte man da das design der klassen realisieren? wo würden welche methoden stehen?
leider habe ich einige schwierigkeiten bei solchen designschritten.
würde später bei der erzeugung einer messung der konstruktor evtl. so aussehen?
mess-klasse messung = new mess-klasse(new messklasse-header, new messklasse-data);
wie würdet ihr das machen, auch in hinsicht auf ein mvc-pattern?
einige code-beispiele würden schon sehr weiterhelfen...
mir sind das einfach zu viele Klassen für so ein Problem. Ich würde zwei Klassen machen. Eine für die Daten und eine fürs Anzeigen der Daten. Getreu dem Leitspruch "Business logic vom GUI trennen". Viele Leute, die nicht richtig objektorientiert programmieren, machen alles mit einer Klasse, aber ich habe den Eindruck, du bist schon wieder zu eifrig beim Klassen bauen.
Die Klasse für die Datenhaltung ist das Model und die Klasse mit der JTable ist eine mögliche View. (Bei Java ist der Controller mit der View gekoppelt.) Damit die View mit dem Model "reden" kann, sollte die Daten-Haltungsklasse das TableModel-Interface implementieren. Die View registriert sich bei der Datenhaltungsklasse als View und wird über Änderungen bei den Daten informiert.
Kennst du das "Java-Buch" von Guido Krüger? Das gibt's als Download von
vielen dank für deine überlegung. leider sind mir die zusammenhänge mit dem mvc-pattern noch nicht eindeutig klar.
(aber das geht hier laut sufu ja vielen so...)
leider ergab sich gestern (nachmittag) keine antwort, wo ich dann fröhlich an meinen klassen 'weiterexperementiert' habe.
dabei sind noch weitere klassen implementiert *bitte nicht schlagen*:
- applikation.java (gui)
- messung.java (messung initialisieren)
- messung_manager.java (kennt messung_import & messung_export)
- messung_import.java (hier wird ein file in die db importiert)
- messung_export.java (hier wird das rs in ein file gespeichert)
- messung_header.java (funktionen, die mit dem header-auslesen eines import-files zu tun haben)
- messung_table_modle.java (erzeugt ein tablemodel für die gui)
- messung_sensor.java (funktionen, die etwas mit den sensoren zu tun haben)
- db.java (stellt kommunikation her, führt queries aus...)
dazu folgende verständnisfragen:
#1: die absicht ist es doch, die ereignisse im 'view' sprich gui (drück button) an den 'controller' zu übergeben, oder? dabei sehe ich irgendwie alle meine klassen als 'controller', da sie die events von der gui entgegennehmen und die berechnungen entsprechend bearbeiten:
in applikation.java:
Code:
void jButton_Import_actionPerformed(ActionEvent e) {
messung_header mh = new messung_header();
mh.getHeaderFromFile(importFile);
}
void jButton_GetColumn_actionPerformed(ActionEvent e) {
messung_table mt = new messung_table();
int i = mh.getColumnCountFromDB();
}
getColumnCountFromDB(){/*Query schreiben und über db-klasse ausführen*/}
#2: die gui kennt die 'controller-ebene' aber nicht die 'model-ebene'?
#2: was bedeutet 'model' und 'controller'? welches ist mein 'model'? habe ich eins?
#3: darf der 'controller' über static-variablen im 'view' verfügen? also sprich:
in der view: applikation.java:
Code:
public static JLabel lable_info = new jLable();
in dem controller:
Code:
messung_manager.java: applikation.lable_info.setText("File ist exportiert");
oder wird das über observer gemacht?
#4: ist die trennung in mehreren klassen nicht erwünscht? sollte ich das in 2 klassen realisieren (1 für tablemodle, 1 für export, import, header, sensoren) wird das doch viel zu 'unübersichtlich'... da kommen doch schnell >3000 codezeilen zusammen.
#5: messung_table_model --> view? ich dachte die gui stellt die 'view'-ebene dar. oder ist die klasse 'messung_tablemodle' auch ein view? wird das dann getrennt behandelt?
----------------------
... viele fragen sorry, aber ich habe mich schon seit 2 tagen mit dem mvc herumgeschlagen, doch bin ich in das einlesen nicht viel schlauer geworden ich hoffe, dass vielleicht sich hier einer 'erbarmt' und mir das anhand meines programms erklären kann. ich stell mir häufig die frage, ob das design welches ich implementiert habe 'gut' ist und in der regel (von programmierern) so gemacht wird.
falls bis heute abend so gegen 22:00 Uhr niemand auf deine Fragen geantwortet hat, will ich versuchen dir zu antworten. (Bin jetzt bei der Arbeit.) Du könntest ja inzwischen mal in Worten beschreiben was dein Programm überhaupt mal so machen soll. Was ist eine Messung, wieviele Messungen gibt es, etc. Aber dabei nicht schon wieder an Klassen denken, sondern eher so eine Art kurzes Pflichtenheft.
Man möge mir Rechschreibfehler und evtl. Codefehler verzeihen. Auch bin ich mit den code-Tags sparsam gewesen.
Am Anfang ein Dankeschön. Hoffentlich komme ich dem MVC-Pattern vom Verständnis ein wenig näher. Da ich noch nie richtige Applikationen programmiert habe, bin ich sehr auf die Hilfe eines erfahrenen Programmierers angewiesen. Ich habe lediglich nur den Unterrichtsstoff parat, aber wirkliche praktische Erfahrung leider nicht :-( Ich hoffe, keinen durch die Fülle meiner Fragen zu nerven. Ich bin schon sehr froh überhaupt Hilfe erwarten zu dürfen. Da ich schon so viele Klassen implementiert habe, kann ich das Projekt nicht ganz nur aus der Sicht eines Pflichtenhefts beschreiben, sondern würde gerne auch meine Klassenimplementation näherlegen, damit du evtl. schnell sehen kannst, was anders zu machen ist oder mir einfach um Feedback zu meiner UML-Implemetierung zu bekommen. Vielen Dank für die Mühe...
Buttons und Bedienung zum Importiren und Exportieren eines Messfiles, sowie zum Anschauen einer jTable
- gui.preferences:
einstellungsapplikation.java
Wird von der 'hauptapplikation' aufgrufen. In dieser Applikation werden Einstellungen gemacht, die in
unterschiedlichen Property-Files gespeichert werden. z.B. werden hier die Daten zur DB-Kommunikation
gesetzt, bestimmt welcher Timestamp gebraucht wird oder ob überhaupt ein Header eingelesen werden soll.
- gui.dialog:
import_dialog.java
wird aus der measurement_import.java aufgrufen, wenn zb. die sensorzahl im header nicht gefunden wird.
das dialogfenster gibt dann die möglichkeit zur manuellen eingabe.
header_dialog.java
wird aus measurement_header.java aufgerufen. hier wird der header in einem Textfeld angezeigt mit der
möglichkeit bestimmte variablen (z.B. Kanalzahl) suchen zu lassen
- gui.dialog.status:
import_status.java (implements Runnable)
wird aus measurement_import.java aufgerufen der den exportStatus mittels progressbar angezeigt
export_status.java (implements Runnable)
wird aus measurement_export.java aufgerufen der den importStatus mittels progressbar angezeigt
- file:
file_export.java
file_import.java
file_property.java
file_property_constant (hier sind Konstanten für das PropertyFile zu finden)
file_log.java
hier werden verschiedene FileArten erzeugt, die Superklasse ist File.
- properties:
setzt und holt die Properties aus einem Property-File (file_property)
- measurement:
measurement_manager.java
dient als Controller und kümmert sich um das importieren und exportieren. Kennt somit die Klassen
measurement_import.java/ export.java.
measurement_import.java
hier sind die Funktionen zu finden, die zum importieren in die DB gebaucht werden. Besitzt eine
Instanz zu der import_status.java aus dem package gui.dialog.status.
measurement_export.java
hier sind die Funktionen zu finden, die zum exportieren aus die DB gebaucht werden. Besitzt eine
Instanz zu der export_status.java aus dem package gui.dialog.status.
measurement_header.java
hier sind Funktionen zu finden, die sich auf den Header beschränken. Besitzt eine Instanz zu der
header_dialog.java aus dem package gui.dialog.
measurement_sensor.java
hier sind Funktionen zu finden, die sich auf die Sensoren beschränken. Hier sollen Senoseren zu
einer Messung aus weiteren Import-Files gesetzt werden. Des Weiteren gibt es Funktionen wie:
int getSensorFromMeasurment(measurementName_) { return tablemodel.getColumnCount(); }
kennt somit die Instanz des Tabellenmodells.
measurement_data.java
hier sind Funktionen zu finden, die sich auf die Daten beschränken: deleteRowsFromMeasurement,
deleteMeasurment, existsMeasurmentInDB, getResultSetFromMeasurment...
measurement_tablemodel.java
hier sind Funktionen zu finden, die sich auf das TabellenModell beschränken. Die Hauptapplikation
erzeugt ein TabellenModel (indem man auf den 'next'-Button drückt) der in einer jTable dargestellt
wird.
db:
db.java
hier wird die Connection zur DB hergestellt (setConnection(), getConnection(), testConnection())
db_mysql.java
hier wird die Connection zu einer MySQL-DB hergestellt. DB ist die Superklasse.
sql:
sql.java
hier werden die Queries verarbeitet. (ResultSet getResultSet(query), makeUpdate(query),...)
thread:
testconnection.java
ein Thread der in Zeitabständen eine Testconnection macht. Wird bei dem Auslesen des Properties (während der Erzeugung der Hauptapplikation) gestartet. Der Zustand soll in der Hauptapplikation über die Farbe eine Lables angezeigt werden. Die Hauptapplikation besitzt somit eine Instanz zur testconnection.java. testconnection.java besitzt eine Instanz zur db.java. Darf das? Ist das nach mvc-Pattern? Müssen hier Observer-Techniken eingesetzt werden?
Ich habe eine Hauptapplikation. In dieser Applikation kann ich MessFiles über ein MenüItem 'Import File...'
in eine DB einlesen. Das MessFile besteht aus einem Header und deren Werte. Das File kann sich in der Art
des Timestamps, dem Header und die Anzahl der Sensoren ändern. Es können beliebig viele Messungen in die DB
gesetzt werden.
Beispiel:
DASYLab - V 7.00.03
Datum 2004-03-09
Zeit : 14:29:41
Kanalzahl : 8
Zeit ;S1-H01 [°C];S1-H01 [%rH];S1-H02 [°C];S1-H02 [%rH];S1-H03[°C];S1-H03[%rH];S1-H04[°C];S1-H04[%rH];
00:00:01 1.000000 2.000000 3.000000 4.000000
00:00:02 -20.000000 0.000000 -20.000000 0.000000
00:00:03 -20.000000 0.000000 -20.000000 0.000000
...
Desweiteren kann über eine ComboBox die Tabelle gewählt werden. Mit 2 Buttons 'last' und 'next'
wird dann ein TabellenModell erzeugt, welches in der Gui (JTable) dargestellt wird. Man blättert sich
sozusagen durch die Tabelle. Der Grund: Da ein Mess-File mehr als >500.000 Zeilen haben kann, ist das
auslesen mittels ResultSet nicht möglich, da der Speicher mit der Datenmenge nicht klarkommt --> MemoryException.
Ein Export kann auch unternommen werden. Die Daten werden aus der DB gelesen und in eine Datei gespeichert.
Dabei können alle Daten exportiert werden oder man selektiert die Spalten aus, welche man benötigt.
Weitere Möglichkeiten über die Hauptapplikation sind:
- Tabelle löschen
- Werte in einer Spalte ändern (vonID, bisID)
Einstellungsapplikation:
Über die Applikation kann man in eine weitere Applikation. Hier werden Einstellungen gemacht, welche
in Property-Files auf der Festplatte abgelegt werden. Hat den Vorteil, dass die Einstellungen des Benutzers
gespeichert werden und beim nächsten Aufruf wieder vorhanden sind. Einstellungen werden gemacht zu:
- Trennungszeichen für den beim Export setzen
- Daten für die Kommunikation zur DB setzen (User, Passwd, Port, Ip...)
- Löschen einer DB
- Anlegen einer DB
- Festlegen welcher Timestamp für das Importieren gebraucht wird
- Ist ein Header im File
Die Properties werden bei der Erzeugung der Applikation gelesen und gesetzt.
Es wird für jedes Messfile eine neue Tabelle erzeugt. Der Name der Tabelle wird aus dem Namen des
Import-Files gesetzt. Die Tabelle wird in die ausgewählte DB erzeugt. Auch hier würde ich gerne ein
evtl. besseres ERM-Design wählen. Auch in Bezug auf Änderungen... Eine Idee?
Es wird eine DB erzeugt (z.B. Test1), wo dann ein ImportFile (messfile_1.lab) in die Tabellen (messfile_1)
geschrieben wird. Die Erzeugung einer neuen DB wird aus der Einstellungsapplikation gemacht. Die Klasse
kennt somit (auch) eine Instanz der measurement_data.java. Darf das? Dürfen z.B. die hauptapplikation
und die einstellungsapplikation beide Instanzen auf measurement_data.java besitzen?
void makeUpdate(String query_) {
/*Verbindung zur DB bzw. Statemant ist über Konstruktor hergestellt*/
db_statement.addBatch(query_);
db_statement.close();
db_connection.close();
}
Mein Problem ist das ganze über das MVC-Pattern zu realisieren. Dabei weiss ich nicht genau, welche Klassen
die 'View' sehen darf und welche Klassen überhaupt alles 'Views' sind. Zählen da auch die Dialog-Klassen zu?
Was ist hierbei mein Model? Was sind die Controller?
Sind die Packages richtig gewählt?
Wie soll die Kopplung zwischen den verschiedenen Klassen sein? Wodurch wird diese Kopplung bestimmt?
Gehören die Dialog und Status-Sachen in einzelne Packages oder sollten die mit in das gui-Package aufgenommen werden?
Wo und wie muss ich bei meinem Design mit Observern arbeiten? Muss ich mit Observern überhaupt gearbeitet werden? Für welche Methode könnte/ sollte man einen Observer schreiben?
Wo spielt das Singelton-Pattern eine Rolle?
Welche Pattern sind noch einzusetzen?
Wie sollten die Interfaces aussehen? Wo sollten diese eingesetzt werden?
Wie wird das System richtig 'gestartet'? In der Main wird nur die Hauptapplikation erzeugt. Oder soll ich das initialisieren (einlesen der Properties, initialiseren von Variablen...) von der Hauptapplikation lösen? evtl. so:
Code:
public static main(){
hauptapplikation hp = new hauptapplikation();
hp.start();
hp.initProperties();
}
ich habe gestern abend noch etwas zusammen geschrieben. Ich hoffe, du kannst es verstehen
und für dich umsetzen. Ich "stecke momentan nicht mehr ganz so tief in Java drin". (Mache beruflich
gerade Objective-C):
Man möge mir Rechschreibfehler und evtl. Codefehler verzeihen.
Zunächst einmal möchte ich meine Zustimmung zu foobars Beitrag zurücknehmen. Ich habe seinen
Beitrag anscheinend nur überflogen und dachte er möchte mich darauf aufmerksam machen, das
Java nicht automatisch Swing ist. Das ist korrekt. Außer Swing gibt's noch das AWT und SWT
und dort könnte das mit der View und den Controllern anders implementiert sein. Weiß ich
aber nicht. Ich habe bisher immer mit Swing gearbeitet und dort ist es so, daß View und
Controller zu einem sogenannten UI-Delegate zusammen gefasst sind.
@ gondor
Was zunächst mal auffällt ist, dass du nicht nur viele Klassen hast, sondern auch viele
Packages. Bei mir sieht die Package-Struktur so aus:
de.wro.businesslogic
de.wro.gui
Das de.wro ist nur wegen des guten Stils. Firmen machen es immer so, dass sie das Länderkürzel
und ihren Namen verwenden, z.B.: com.sun etc. Ich habe zwar keine Firma, aber stelle immer
mein de.wro voran. Das hat den Vorteil, dass wenn ich ein Framework verwenden würde, das
ebenfalls ein GUI-Package hat, ich die beiden Packages leichter auseinander halten kann.
Wenn das Projekt etwas größer und somit unübersichtlicher wird, dann fange ich an unterhalb
von gui und businesslogic noch weitere Packages einzufügen.
Zunächst mal noch eine Frage zum DB-Design. Was ist der Grund, dass jede Datei, die importiert
wird in einer eigenen Tabelle gespeichert wird?
Du hast dich nicht darüber ausgelassen, wieviele Messungen dein Programm gleichzeitig bearbeiten
kann. Der Einfachheit halber nehme ich jetzt an, es kann immer nur eine Messung/Tabelle/Datei
bearbeitet werden.
Deine Klasse hauptapplikation.java müßte eigentlich ein JFrame oder davon abgeleitet sein.
Außerdem sollte sie die public static void main()-Methode enthalten.
Die Datenmengen, mit denen du hantierst scheinen relativ groß zu sein. Um mal eine Beispiel-
Applikation zu beschreiben, nehme ich jetzt mal an, die Datenmenge wäre relativ gering. D.h.
Man könnte eine Mess-Datei locker komplett im Hauptspeicher halten. Dann bräuchte man eine
Klasse dafür, ich nenne sie jetzt einfach mal Messung. Diese Klasse wäre für die Datenhaltung
zuständig und somit das Model. Wenn der Benutzer deines Programms eine Datei auswählt, so
würde man eine Instanz der Klasse Messung erzeugen und dieser Klasse sagen aus welcher Datei
sie die Daten laden soll:
Code:
boolean loadDataFromFile(String fileName) {
}
Oder wenn die Daten aus der DB kommen sollen, bräuchte man noch eine Methode für das Holen
aus der DB:
Code:
boolean loadDataFromDB(String tableName, String sqlSelect, ... oder was eben
sonst noch für Parameter notwendig sind, um die Daten eindeutig zu spezifizieren) {
}
Die Daten würden z.B. In einer ArrayList landen, die aber nicht nach außen sichtbar ist.
Wie die Klasse Messung ihre Daten verwaltet ist allein ihre Sache und wird nicht nach
außen getragen. (Stichwort: Datahiding) Nun sollen die Daten in einer Tabelle angezeigt
werden. Dazu ist ein JTable-Objekt meinetwegen in deinem Hauptfester namens
hauptapplikation.java vorgesehen. Dieses JTable-Objekt ist eine View. (Es könnte noch
weiter Views geben.)
Damit die Klasse Messung als Model für die JTable dienen kann, muss sie einigen
Anforderungen gerecht werden. Diesen Anforderungen kann sie auf zwei Art und Weisen
gerecht werden. Entweder sie erbt von der Klasse AbstractTableModel. Ich habe vorhin
keine Aussage gemacht von wem die Klasse Messung erbt. Angenommen sie erbt von JObject,
dann ist es kein Problem JObject als Vater durch AbstractTableModel zu ersetzten. Aber
angenommen die Klasse Messung würde bereits von einer Klasse AbstractMessung erben.
Wegen fehlender Mehrfachvererbung kann sie jetzt nicht auch noch von AbstractTableModel
erben. Für diesen Fall gibt's das Interface TableModel. Im Prinzip kommt's letzten ´
Endes aber auf's selbe raus. Die Klasse Messung muß bestimmte Methoden implementieren
um als Model für das JTable-Objekt fungieren zu können.
Diese Methoden sind:
Code:
public int getRowCount() {
return 0;
}
public int getColumnCount() {
return 0;
}
public String getColumnName(int columnIndex) {
return null;
}
public Class<?> getColumnClass(int columnIndex) {
return null;
}
public boolean isCellEditable(int rowIndex, int columnIndex) {
return false;
}
public Object getValueAt(int rowIndex, int columnIndex) {
return null;
}
public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
}
public void addTableModelListener(TableModelListener l) {
}
public void removeTableModelListener(TableModelListener l) {
}
Das sind jetzt mal nur die Methoden Rümpfe, die ich mir schnell von IntelliJ Idea habe
erzeugen lassen. Diese müssen natürlich noch mit Leben gefüllt werden.
Die Klasse JTable hat 3 Konstruktoren, deren erstes Argument immer ein TableModel ist.
Dein JTable-Objekt muss also mit Hilfe eines solchen Konstruktors erzeugt werden.
(Ok, man kann das Model auch noch nachträglich via setModel() zuweisen.) In dem Moment
in dem die JTable ihr Model kennt, registriert sie sich auch als Listener bei diesem Model.
D.h die View (JTable-Objekt) kennt sein Model. Das Model (Messung-Objekt) kennt seine
Views nur als Listener.
Wenn jetzt sich z.B. ein Messwert im Model ändert, (Wieso und warum und von wem, sei j
etzt einfach mal so dahingestellt.) dann teilt das Model allen seinen Listenern mit,
dass sich Daten geändert haben. Es bleibt der View (JTable-Objekt) überlassen, wie es
auf die Änderungsnachricht reagiert. Im Normalfall wird es seine anzuzeigenden Daten
neu vom Model anfordern und anzeigen.
So weit so gut. Jetzt haben wir noch nicht vom Controller gesprochen. Da deine Messdateien
sehr groß sind, können nicht alle Daten gleichzeitig im Hauptspeicher gehalten werden.
Deshalb hast du noch 2 Buttons zum Vor- und Zurückblättern in deinem GUI angebracht.
Angenommen die JTable zeigt immer 20 Zeilen, dann kann mit diesen Button jeweils um 20
Zeilen vor oder zurückgeblättert werden. D.h. die Buttons müssen Zugriff auf die Messung-
Instanz haben und die Klasse Messung muss auch zwei Methoden vorsehen, die die Buttons
aufrufen können, wenn sie angeklickt werden.
Code:
void loadNextRows(int anzahl);
void loadNextRows(int anzahl);
// oder meinetwegen auch
void loadNextRows(int number);
void loadNextRows(int number);
Ist immer so hübsch häßlich, wenn deutsche und englische Ausdrücke gemischt werden.
(Mache ich aber trotzdem immer wieder.)
Das Model muss dann selber wissen, ob es die Daten nun von der DB oder von einer Datei
holen muss. Nach dem Holen der 20 Zeilen müssen wieder sämtliche Listener über die
Änderung benachrichtig werden. Obwohl die Buttons im selben Frame wie die JTable sind,
müssen sie nichts über die JTable wissen.
measurement_tablemodel.java
hier sind Funktionen zu finden, die sich auf das TabellenModell beschränken. Die >Hauptapplikation
erzeugt ein TabellenModel (indem man auf den 'next'-Button drückt) der in einer jTable dargestellt
wird.
Das stimmt so nicht. Beim Öffnen einer Datei oder Anzeigen einer Tabelle aus der DB über das Menü
wird ein Messung-Objekt erzeugt. Ein Klick auf den Next-Button benachrichtig das Model nur darüber,
dass die nächsten Datensätze angezeigt werden sollen. Beim Öffnen der nächsten Datei wird das alte
Model weggeworfen und eine neues erzeugt. Dieses Model wird via setModel der View (JTable) bekannt
gemacht und die Buttons greifen z.B. über eine Referenz zu, die der Frame besitzt.
Code:
private Messung aktuelleMessung;
Wenn also eine neue Datei geöffnet wird, sagt man:
Code:
aktuelleMessung = new Messung();
aktuelleMessung. loadDataFromFile(dateiName);
myTable.setModel(aktuelleMessung);
(Ich will jetzt nicht darauf eingehen, warum ich es für sinnvoll halte, das Model beim Umschwenken
auf eine andere Datei wegzuwerfen anstatt es weiter zu verwenden, was man auch machen könnte.)
Das ist jetzt mal ein grobes Gerüst für deine Applikation. Nun hast du noch viele andere
Funktionalität und Klassen eingebaut. Das ist soweit auch korrekt. Zum Beispiel die Methode
Code:
[quote]void loadNextRows(int number);
bedient sich natürlich irgendwelcher Klassen die für den Zugriff auf die DB zuständig sind.
Es ist auch sinnvoll das über Hilfsklassen zu kapseln. Wieviele man dazu benötigt ist wieder
eine andere Frage. Ich würde es auf jeden Fall so machen, dass die MySQL spezifischen Sachen
in einer Klasse gekapselt werden, so dass beim Austausch der DB nur diese eine Klasse ersetzt
werden muss. Aber das scheinst du auch so schon zu machen.
Wo und wie muss ich bei meinem Design mit Observern arbeiten? Muss ich mit Observern
überhaupt gearbeitet werden? Für welche Methode könnte/ sollte man einen Observer schreiben?
MVC ist eine mögliche Ausführung des Observer-Patterns, folglich haben wir das Observer-Pattern
bereits angewandt.
Ich habe jetzt nicht mehr die Zeit auf alle deine Fragen einzugehen, ich hoffe meine Ausführungen
beantworten die eine oder andere Frage auch noch so. Wichtig ist einfach zu wissen, dass das
Model die wichtigste Klasse in der Anwendung ist. Sie macht ihre Arbeit aber nicht allein,
sondern bedient sich anderer Klassen um die Aufgabe zu lösen, die der Benutzer an sie stellt.
Sie delegiert z.B. die Aufgabe die nächsten 20 Zeilen aus der Datei zulesen an eine File-Instanz.
Der Button, der das Lesen veranlaßt hat, kennt aber nur das Model. Ihm ist es letztendlich egal
wer die Daten aus der Datei liest.
sorry, aber ich habe mich schon seit 2 tagen mit dem mvc herumgeschlagen, doch bin ich in das einlesen nicht viel schlauer geworden 
