In beiden Programmen besteht das ganze Programm aus einer
Klasse, wie aus einem Stück Stein geschnitzt: Diese Art der Programmierung heißt
monolithisch. Für kleinere Programme
ist diese Vorgehensweise geeignet, aber wenn die Anzahl der Programmzeilen über
eine bestimmte Grenze hinauswächst, wird sie unübersichtlich.
Hierbei ist
Model autonom: Es ist unabhängig
von den beiden anderen. Es enthält die Daten und Algorithmen, die die
Geschäftslogik der Anwendung abbilden. Bei der Uhr ist dies der Teil, der
unabhängig davon ist, ob die Uhrzeit digital oder kreisförmig dargestellt wird;
auch davon, ob die Uhr gesteuert wird oder nicht.
Die
View enthält die Darstellung der aktuellen Daten. Dabei kann es
für ein Model
mehrere unterschiedliche Views geben: für die Uhr die Digitalanzeige oder die
kreisförmige. View
ist abhängig vom Model,
zumal sie von ihm die Daten (wie die aktuelle Uhrzeit) abholen soll.
Das
Control (die Steuerung) initiiert jede Veränderung in der
Anwendung, sei das am Model
oder an der Darstellung. Bei der Uhr gehört zu ihren Aufgaben das Ticken der Uhr
(jede Sekunde bzw. alle fünf Sekunden), sowie die Ereignisbehandlung (für die
Knöpfe oder über die Tasten).
Control benachrichtig sowohl
Model wie
auch View(s) über etwaige Veränderungen:
Model muss dann seine Daten
aktualisieren und die View(s) muss/müssen die aktuellen Daten vom
Model abholen,
um sie darzustellen.
Gegebenenfalls können mehrere Controls unabhängig
voneinander am selben Model und an denselben Views agieren. Bei mehreren Views
ist es möglich, dass jede View ihr eigenes Control hat.
Aus dieser Aufgabenteilung ergeben sich folgende
Beziehungen:
Die Pfeile bezeichnen die Abhängigkeiten, d.h. „wer kennt
wen“: Model
ist autonom, View
kennt Model, Control
kennt beide. Aus dieser Struktur ergibt sich ein typisches Hauptprogramm in Java
für den Fall von einer View:
public
static
void
main(String[] args) {
IModel model =
new
Model();
new
Control(model,
new
View(model)); }
Die Signaturen der Konstruktore der drei Klassen sind
demnach:
Model()
View(IModel)
Control(IModel, IView)
wobei
Model
implements
IModel und
View
implements
IView.
Weil niemand von Control
abhängig ist, braucht es keine Schnittstelle.
Im Falle von mehreren Views gibt es drei Möglichkeiten:
1. Entweder steuert ein Control alle Views,
2. oder hat jede View ihr eigenes Control-Objekt
derselben Klasse
3. oder hat jede View ihre eigene Control-Klasse
Im dritten Fall wird jede Control-Klasse instanziiert:
new
Control1(model,
new
View1(model));
new
Control2(model,
new
View2(model));
…
Im zweiten Fall wird für jede View ein eigenes Control-Objekt
derselben Klasse instanziiert:
new
Control(model,
new
View1(model));
new
Control(model,
new
View2(model));
…
Im dritten Fall muss Control alle Views kennen, daher ist
seine Konstruktorsignatur
Control(IModel, IView[])
Und es wird mit
new
Control(model,
new
View[] {
new
View1(model),
new
View2(model), …);
instanziiert. Alternativ ist der Konstruktor mit einer
Signatur
Control(IModel, Collection<IView>)
vorstellbar.
Version: 19. April 2012
© Prof. Solymosi, 20102 Beuth-Hochschule für Technik Berlin, Fachbereich VI (Informatik und Medien)
solymosi
bht-berlin.de