CS1005 Objektorientierte Programmierung Bachelor of Science (Informatik)

Transkript

1 CS1005 Objektorientierte Programmierung Bachelor of Science (Informatik) Graphische Benutzerschnittstellen II GUI und Aktionen verknüpfen MVC-Muster Seite 1

2 GUI mit Aktionen verknüpfen Seite 2

3 ActionListener ActionListener : GUI-Komponenten mit Anwendungslogik verbinden Ereignis: Benutzer drückt Taste / bewegt Maus GUI-Elemente registrieren diese externen Ereignisse... erzeugen interne Ereignisse... und leiten sie weiter an ihre ActionListener ActionListener verarbeitet interne Ereignisse KLICK internes Ereignis externes Ereignis ActionListener: passt auf, ob irgendwo sich etwas regt EreignisObjekt ActionListener ActionListener Klick verarbeiten Klick verarbeiten einlistener JButton JButton einknopf Verbindung herstellen einknopf.addactionlistener(einlistener) Seite 3

4 ActionListener: Beispiel public static void main(string[] args) { JFrame frame = new JFrame(); frame.setdefaultcloseoperation(jframe.exit_on_close); frame.setlayout(new FlowLayout()); JButton b = new JButton("KlickMich!"); frame.add(b); //Knopf mit ActionListener verbinden b.addactionlistener(new OhEsKlickt()); Knopf b mit einem ActionListener verbinden frame.setvisible(true); namenloses OhEsKlickt-Objekt new Der ActionListener definiert was passiert, wenn der Knopf geklickt wird namenloses ActionListener-Objekt class OhEsKlickt implements ActionListener { public void actionperformed(actionevent arg0) { System.out.println("Oh Ja, das Klickt!"); Seite 4

5 ActionListener: Darstellung mit Sequenzdiagramm :OhEsKlickt public class Test { public static void main(string[] args) {... b : JButton addactionlistener( ) actionperformed main-thread Klick! Event-Dispatcher-Thread addactionlistener: Von main aus (direkt oder indirekt über beliebig viele Methodenaufrufe) wird das namenlose Objekt der Klasse OhEsKlickt als ActionListener beim Objekt b regisitriert. Klickt dann irgendwann der Benutzer den Knopf b... dann wird dies vom Event-Dispatcher-Thread bemerkt, und er aktiviert den bei b registrierten ActionListener... genau genommen ruft er dessen Methode actionperformed auf Seite 5

6 ActionListener als anonyme innere Klasse public static void main(string[] args) { JFrame frame = new JFrame(); frame.setdefaultcloseoperation(jframe.exit_on_close); frame.setlayout(new FlowLayout()); JButton b = new JButton("KlickMich!"); JLabel l = new JLabel(); frame.add(b); frame.add(l); Anonyme innere Klasse: Abgekürzte Notation. Spart eine extra Klassendefinition. Eigentlich will man ja nur eine Aktion (Methode) mit dem Knopf verbinden. Formal muss dazu aber eine Klasse (mit dieser Methode) definiert werden. // ActionListener: Klassendfinition und Instanzerzeugung // in einem b.addactionlistener( new ActionListener(){ public void actionperformed(actionevent arg0) { System.out.println("Oh Ja, das klickt"); ); frame.setvisible(true); Methodendefinition Definition einer anonymen inneren Klasse (Klasse ohne Namen, in einer Methode definiert) Seite 6

7 explizit definierte / anonyme innere Klasse Äquivalente Varianten: explizit (normal) definierte Klasse oder anonyme innere Klasse public static void main(string[] args) { JFrame frame = new JFrame(); frame.setdefaultcloseoperation(jframe.exit_on_close); frame.setlayout(new FlowLayout()); JButton b = new JButton("KlickMich!"); frame.add(b); b.addactionlistener( new ActionListener(){ public void actionperformed(actionevent arg0) { System.out.println("Oh Ja, das klickt"); public static void main(string[] args) { JFrame frame = new JFrame(); ); frame.setdefaultcloseoperation(jframe.exit_on_close); frame.setvisible(true); frame.setlayout(new FlowLayout()); JButton b = new JButton("KlickMich!"); frame.add(b); //Knopf mit ActionListener verbinden b.addactionlistener(new OhEsKlickt()); Variante mit anonymer innerer Klasse frame.setvisible(true); class OhEsKlickt implements ActionListener { public void actionperformed(actionevent arg0) { System.out.println("Oh Ja, das Klickt!"); Seite 7 Variante mit explizit definierter Klasse

8 Kommunikation mit GUI-Elementen Seite 8

9 Textfelder: Werte setzen / abfragen Das Programm (der main-thread) kann in vielfältiger Weise auf GUI-Elemente zugreifen um Werte und Eigenschaften zu setzten (die dann eventuell sichtbar werden) um Werte und Eigenschaften zu lesen (die eventuell vom Benutzer eingegeben wurden) Beispiel Textfeld: settext: Text sichtbar machen gettext: Benutzereingaben lesen :ActionListener public class Test { public static void main(string[] args) {... t : JTextField addactionlistener( ) actionperformed Event-DispatcherThread Benutzer Aktion settext main-thread (Programm-gesteuerte Aktionen) gettext Seite 9

10 Ereignisorientierte Programme Interaktive Programme sind ereignisorientiert: sie werden im wesentlichen über den Event-Dispatcher gesteuert. Benutzeraktionen modifizieren GUI-Elemente und aktivieren ActionListener diese lesen Informationen aus (anderen) GUI-Elementen und modifizieren deren Inhalt und Aussehen :ActionListener b : JButton t : JTextField Event-DispatcherThread addactionlistener( ) KLICK actionperformed gettext Info verarbeiten, dann anzeigen Tipp settext Zeigen Seite 10

11 Ereignisorientierung: Auf Klick hin addieren public class AddiererGUI extends JFrame { private JButton plusb; private JTextField op1tf; private JTextField op2tf; private JTextField resulttf; public AddiererGUI() { super("addierer"); initview(); setlistener(); gettext parseint settext private void setlistener() { plusb.addactionlistener( new ActionListener() { public void actionperformed(actionevent arg0) { resulttf.settext( "" // String-Wert erzwingen + ( Integer.parseInt( op1tf.gettext() ) + Integer.parseInt( op2tf.gettext() ) ) gettext parseint + private void initview() {...wie oben ); ); Seite 11

12 View MVC: Model, View, Control Control Seite 12 Model

13 MVC: ein bekanntes Entwurfsmuster MVC: Entwurfsmuster (design pattern) zur Gestaltung von GUI-Anwendungen Model View Control Modell (Logik / Zustand) der Anwendung Darstellung des Modells, Interaktion mit dem Benutzer (GUI) Kontrolle, Benutzerführung, Aktionsverarbeitung Die GUI-Anwendung wird in die drei Bereiche organisiert, die jeweils eine der drei Hauptaufgaben übernehmen. Model, View und Control werden als Klassen mit einem Exemplar realisiert Seite 13

14 Addierer nach MVC-Muster Addierer im MVC-Muster: Model Eine Welt von drei Werte v1, v2, s. Die dritte (s) ist dabei immer die Summe der beiden anderen (v1, v2) View Darstellung des Modells, also der drei Zahlen. Außerdem Möglichkeit für Benutzeraktionen: der Knopf Control Kontrolle, Benutzerführung, Aktionsverarbeitung: Benutzer klickt Knopf. v1 und v2 im Model werden an die eingegebenen Werte angepasst. Control: steuert Reaktion auf Benutzeraktionen Control oder Berechnungen set(2,3) Model statt AddiererGUI update(''5'') Model:verwaltet / berechnet Daten; aktualisiert View Seite 14 action(''2'',''3'') View View: zeigt Modell, bemerkt Benutzeraktionen

15 Addierer nach MVC-Muster (1) public class AddiererModel { private int v1; private int v2; private int s; // INV s = v1+2 private AddiererView view; public AddiererModel(AddiererView view) { this.view = view; void set(int v1, int v2){ System.out.println("SET "+v1+ " "+v2); this.v1 = v1; this.v2 = v2; s = v1 + v2; set(2,3) view.update(s); Model update(''5'') Model muss View kennen. Die Bekanntschaft wird im Konstruktor gesetzt Seite 15

16 Addierer nach MVC-Muster (2) public class AddiererControl { private AddiererModel model; public AddiererControl(AddiererModel model) { this.model = model; void action(string s1, String s2){ model.set( Integer.parseInt(s1), Integer.parseInt(s2) ); Control action(''2'',''3'') set(2,3) Control muss Model kennen. Die Bekanntschaft wird im Konstruktor gesetzt Seite 16

17 Addierer nach MVC-Muster (3) public class AddiererView extends JFrame { private JButton plusb; private JTextField op1tf, op2tf, resulttf; private AddiererControl control; public AddiererView() { super("addierer"); initview(); setlistener(); void setcontrol(addierercontrol control){ this.control = control; private void initview() {... update(''5'') View View muss Conrol kennen. Die Bekanntschaft wird mit Methode gesetzt private void setlistener() { plusb.addactionlistener( new ActionListener() { public void actionperformed(actionevent arg0) { control.action( op1tf.gettext(), op2tf.gettext()); ); // Ende setlistener void update(int v){ resulttf.settext( ""+v ); Seite 17

18 Addierer nach MVC-Muster (4) public class Addierer { public static void main(final String[] args){ AddiererView addierview = new AddiererView(); AddiererModel model = new AddiererModel(addierView); AddiererControl control = new AddiererControl(model); addierview.setcontrol(control); addierview.setvisible(true); Control Hauptklasse Addierer: Komponenten erzeugen und miteinander verbinden (bekannt machen) Model View Die MVC-Struktur ist für dieses Trivial-Beispiel natürlich nicht notwendig. Bei komplexeren Anwendungen aber wichtiges, notwendiges und sehr hilfreiches Gestaltungselement. Seite 18

19 MVC MVC Kernidee: Trenne Anwendung, Dialogsteuerung und Präsentation Anwendung (Model): Daten, Zustand der Anwendung, Algorithmen Controller: Verbindung GUI Model, Reaktion auf Benutzeraktionen, Benutzerführung Fehlerhafte Eingaben abfangen,... GUI (View): Darstellung des Modells (Zustand der Anwendung), Aktionsmöglichkeiten bieten Seite 19

20 MVC MVC Beispiel Taschenrechner Seite 20

21 MVC MVC-Muster Taschenrechner Model Daten, Zustand der Anwendung, Algorithmen Control Verbindung GUI Model, Reaktion auf Benutzeraktionen, Benutzerführung View Darstellung des Modells (Zustand der Anwendung), Aktionsmöglichkeiten bieten. Seite 21

22 Taschenrechner: Main package rechner; public class Main { public static void main(string[] args) { Model model = new Model(); Control control = new Control(model); View view = new View(control); model.setcontrol(control); control.setview(view); view.setvisible(true); Bekanntschaften setzen: welches Objekt kennt welches andere: - control kennt model (via Konstruktor): lässt rechnen - view kennt control (via Konstruktor): lässt Eingaben verarbeiten - model kennt control (via setcontrol): breichtet über Rechnenwerte - control kennt view (via setview): zeigt Werte / Fehler an model control view Seite 22

23 Taschenrechner / GUI Taschenrechner GUI (View): sehr einfacher Rechner: Grundrechenarten auf ganzen Zahlen Layout: GridBagLayout Komponenten tabellenartig anordnen, mit Komponenten die sich über mehrere Zeilen / Spalten erstrecken. x y Seite 23

24 Taschenrechner / GUI GridBagLayout: Komponenten werden in einem Gitter / einer Tabelle platziert mit Angabe von: x-position (Spalte) y-position (Zeile) Höhe (in Zeilen) Weite (in Spalten) Positionsangaben als GridBagConstraints, die bei add mit angegeben werden setlayout(new GridBagLayout()); GridBagConstraints c = new GridBagConstraints(); //Komponenten so breit wie ihr Platz: c.fill = GridBagConstraints.HORIZONTAL; c.gridwidth = 4; // Weite: 4 Spalten c.gridx = 0; // Spalte 0 c.gridy = 0; // Zeile 0 add(displaytf, c); // Textfeld dahin! c.gridwidth = 2; // Weite jetzt 2 c.gridx = 4; // x-position jetzt 4 add(new JLabel("SuperCalc", SwingConstants.CENTER), c); Die erste Zeile des Taschenrechners: 4 Spalten für Textfeld, 2 Spalten für Label Seite 24

25 Taschenrechner / GUI - Rahmen public class View extends JFrame { private JButton[] digitbutton = new JButton[10]; private JButton[] opbutton = new JButton[4]; private JButton eqbutton; private JButton clearbutton; private JTextField displaytf; char[] ops = { '+', '-', '*', '/' ; private Control control; View(Control control) { super("calculator"); this.control = control; initgui(); setlistener(); private void initgui() {... private void setlistener() {... Seite 25

26 Taschenrechner / GUI initgui (1) private void initgui() { for (int i = 0; i < 10; i++) { digitbutton[i] = new JButton("" + i); digitbutton[i].setfont(new Font("monspaced", Font.PLAIN, 20)); for (int i = 0; i < 4; i++) { opbutton[i] = new JButton("" + ops[i]); opbutton[i].setfont(new Font("monspaced", Font.PLAIN, 20)); eqbutton = new JButton("="); eqbutton.setfont(new Font("monspaced", Font.PLAIN, 20)); clearbutton = new JButton("clear"); clearbutton.setfont(new Font("spaced", Font.ITALIC, 12)); displaytf = new JFormattedTextField(new java.text.decimalformat()); displaytf.setcolumns(10); displaytf.sethorizontalalignment(jtextfield.right); displaytf.setfont(new Font("monspaced", Font.PLAIN, 20)); displaytf.seteditable(false); displaytf.setbackground(color.light_gray); Seite 26

27 Taschenrechner / GUI initview (2) setlayout(new GridBagLayout()); GridBagConstraints c = new GridBagConstraints(); c.fill = GridBagConstraints.HORIZONTAL; c.gridwidth = 4; c.gridx = 0; c.gridy = 0; add(displaytf, c); c.gridwidth = 2; c.gridx = 4; add(new JLabel("SuperCalc", SwingConstants.CENTER), c); c.gridwidth = 1; c.gridx = 0; c.gridy = 1; add(digitbutton[7], c); c.gridx = 1; add(digitbutton[8], c); c.gridx = 2; add(digitbutton[9], c); c.gridx = 4; add(opbutton[0], c); c.gridx = 5; add(opbutton[1], c); Seite 27

28 Taschenrechner / GUI initview (3) c.gridx = 0; c.gridy = 2; add(digitbutton[4], c); c.gridx = 1; add(digitbutton[5], c); c.gridx = 2; add(digitbutton[6], c); c.gridx = 4; add(opbutton[2], c); c.gridx = 5; add(opbutton[3], c); c.gridx = 0; c.gridy = 3; add(digitbutton[1], c); c.gridx = 1; add(digitbutton[2], c); c.gridx = 2; add(digitbutton[3], c); c.gridx = 4; c.gridwidth = 2; add(eqbutton, c); c.gridwidth = 1; add(digitbutton[3], c); c.gridx = 4; c.gridwidth = 2; add(eqbutton, c); c.gridwidth = 1; c.gridx = 0; c.gridy = 4; c.gridwidth = 3; add(digitbutton[0], c); c.gridx = 4; add(clearbutton, c); Seite 28 pack();

29 Taschenrechner : Automat Taschenrechner als Automat Zwei Ebenen Ebne der Ziffern Ziffer-Eingaben / Operator-Eingaben verarbeiten Eingegebene Ziffern speichern und zu Zahlen zusammensetzen Ebene der Zahlen eingegebene / berechnete Zahlen für die nächste Operation speichern eingegebenen Operator / eingegebene Zahlen zu neuer Zahl verarbeiten 00 neue Ziffer zu der Zahl die gerade aufgesammelt wird ++ Ziffer-Sammeln beenden, Zahl merken, Operator merken == Ziffern sammeln beendet, Zahl mit alter Zahl und Operator verknüpfen Seite 29

30 Taschenrechner : Automat Aufteilung des Verhaltens in zwei parallel arbeitende Automaten: Tasten-Annahme / -Verarbeitung (Tastendruck-Verarbeitung / Ziffer ~> Zahl) Zahlen-Annahme / -Verarbeitung (Verarbeitung von Zahlen und Operationen) Ziffer +-*/ = Front Zahl, op baut Zahl auf in acc1 Zahl, = Ergebnis Zustand: gesammelte Ziffern Back verwaltet op, verwaltet acc2, rechnet Zustand: gespeicherte Zahl und Operator acc1: 1-ter Akkumulator, Sammelstelle für Ziffern acc2: 2-ter Akkumulator, Aufbewahrung des ersten Operanden op: aufbewahrter Operator Seite 30

31 Taschenrechner : Front-Automat Front-Automat Eingabeannahme Ziffernfolge zu Zahlen aufbauen < Zahl / Operator > oder < Zahl / = > an Back-Automat übergeben Back <123, +> acc1 Seite 31

32 Taschenrechner : Front-Automat als UML / Statechart =/ sendcomp(acc1) / acc1 = 0 receiveerg(v) / acc1 = v Input InputPending Ziffer / acc1 = acc1*10 + Ziffer Ziffer / acc1 = Ziffer Zustand op / sendop(acc1, op) Front-Automat: verwaltet Zahl (in acc1) sammelt Ziffern zu Zahlen auf nimmt Ergebnis an sendet <Zahl, => oder Operator UML: Zustands(übergangs)Automat, Zustands(übergangs)Diagramm Statechart Ereignis Aktion Ereignisse: - Ziffer : Eingabe einer Ziffer - op: Eingabe eines Operators - = : Eingabe '=' - receiveerg: Ergebnis von Back Zustände: bei Zahleingabe oder Beginn neue Zahl Seite 32

33 Taschenrechner : Front-Automat als UML / Statechart =/ sendcomp(acc1) / acc1 = 0 receiveerg(v) / acc1 = v Input InputPending Ziffer / acc1 = acc1*10 + Ziffer composite State Ziffer / acc1 = Ziffer Zustand op / sendop(acc1, op) Front-Automat startet im Zustand Input, acc1 wird = 0 gesetzt. Im Zustand Input: - ankommenden Ziffern werden gesammelt Im Zustand InputPending - ein eintreffender Wert v vom Back-Automat wird in acc1 gespeichert Ereignis Aktion in jedem Zustand: - eine '='-Eingabe führt in den Zustand InputPending und zum Senden des acc1-wertes - eine '+', '-', '**, oder '/' Eingabe führt in den Zustand InputPendimg und dazu, dass der Operator und der Wert von acc1 an den BackAutomat gesendet wird. Seite 33

34 Taschenrechner : MVC Front-Automat => Control-Komponente zusätzlich Clear-Taste Fehlereingaben abfangen Fehlermeldungen von Model annehmen View informieren Back-Automat => Model-Komponente zusätzlich reset-funktion Arithmetik-Fehler abfangen View / Control informieren Eine Aufteilung von beliebig vielen möglichen! Seite 34

35 Taschenrechner : Automat als Model und Control Aufteilung des Verhaltens in zwei parallel arbeitende Automaten: Control: Tasten-Annahme / -Verarbeitung (Tastendruck-Verarbeitung / Ziffer ~> Zahl) Model: Zahlen-Annahme / -Verarbeitung (Verarbeitung von Zahlen und Operationen) Control Ziffer +-*/ = baut Zahl auf in acc1 sendop receiveop sendcomp receivecomp sendreset receivereset receiveerg senderg Model verwaltet op, verwaltet acc2, rechnet Zustand: gespeicherte Zahl und Operator Zustand: gesammelte Ziffern acc1: 1-ter Akkumulator, Sammelstelle für Ziffern acc2: 2-ter Akkumulator, Aufbewahrung des ersten Operanden op: aufbewahrter Operator Seite 35

36 Taschenrechner : Control-Komponente / UML =/ sendcomp(acc1) / acc1 = 0 digitc = 0 Input Ziffer / [digitc < MAX] acc1 = acc1*10 + Ziffer digitc++ receiveerg(v) / acc1 = v clear / sendreset() InputPending Ziffer / acc1 = Ziffer digitc = 1 clear / sendreset() op / sendop(acc1, op) receiveerr Ziffer / [digitc >= MAX] Front (Control) mit Fehlerkontrolle: eingegebene Ziffern werden gezählt; clear führt zu Re-Initialisierung. Back (Model) kann Fehler melden; nur clear führt aus dem Fehler-Zustand Seite 36 Error

37 Taschenrechner : Control-Komponente / Java (1) public class Control { private enum State { INPUT, INPUTPENDING, ERROR ; private State state = State.INPUT; private long acc1 = 0; private int digitc = 0; private final int MAXDIGIT = 12; private Model model; private View view; public void setview(view view) { this.view = view; public Control(Model model) { this.model = model; Seite 37

38 Taschenrechner : Control-Komponente / Java (2) void setdigit(int d) { switch (state) { case INPUT: if ( digitc > MAXDIGIT ) { state = State.ERROR; view.newtext("error"); return; acc1 = acc1*10 + d; view.newtext(""+acc1); digitc++; state = State.INPUT; break; case INPUTPENDING: acc1 = d; view.newtext(""+acc1); Zifferneingabe verarbeiten: digitc = 1; in welchem Zustand bin ich state = State.INPUT; was tun? break; was ist der nächste Zustand? Seite 38

39 Taschenrechner : Control-Komponente / Java (3) void setequal() { switch (state) { case INPUT: state = State.INPUTPENDING; sendcomp(acc1); break; case INPUTPENDING: state = State.INPUTPENDING; sendcomp(acc1); break; '='-Eingabe verarbeiten Operator-Eingabe verarbeiten void setop(char op) { switch (state) { case INPUT: state = State.INPUTPENDING; sendop(acc1, op); break; case INPUTPENDING: state = State.INPUTPENDING; sendop(acc1, op); break; Seite 39

40 Taschenrechner : Control-Komponente / Java (3) public void clear() { state = State.INPUT; digitc = 0; acc1 = 0; sendreset(); view.newtext(""+acc1); Clear-Taste verarbeiten void receiveerg(long erg) { Ergebnis-Wert von Model switch (state) { (Back) verarbeiten case INPUT: System.err.println("receive in state Input"); case INPUTPENDING: acc1 = erg; view.newtext(""+acc1); break; public void receiveerror() { state = State.ERROR; view.newtext("error"); Fehlermeldung von Model (Back) verarbeiten Seite 40

41 Taschenrechner : Control-Komponente / Java (4) private void sendcomp(long acc1) { model.receivecomp(acc1); Hilfsroutine: Wert an Model senden private void sendop(long acc1, char op) { model.receiveop(acc1, op); Hilfsroutine: Wert und Operator an Model senden private void sendrest() { model.receivereset(); Hilfsroutine: Reset an Model senden Seite 41

42 Taschenrechner : Model-Komponente / UML receiveop(v, op) / ops = op acc2 = v OpPending OpWait Warte auf Operator receiveop(v, op) / acc2 = acc2 ops v ops = op senderg(acc2) receivecomp(v) / acc2 = acc2 ops v senderg(acc2) receivereset() / acc2=0 Statechart der Model-Komponente Back-Automat (Model): verwaltet Operator (in ops) verwaltet Zahl (in acc2) nimmt Zahl plus = oder Operator an sendet Ergebnis habe unverarbeiteten Operator Ereignisse (Empfangsereignisse von Front) - receiveop(wert): Wert plus Operator - receivecomp(wert) : Wert plus = - receivereset(): acc2 = 0 Zustände: ohne oder mit hängendem Operator Seite 42

43 Taschenrechner : Model-Komponente / Java (1) package rechner; public class Model { private char ops; private long acc2; private enum State { OPWAIT, OPPENDING ; private State state = State.OPWAIT; public Control control; public void setcontrol(control control) { this.control = control; void receiveop(long v, char op) { switch (state) { case OPWAIT: ops = op; acc2 = v; state = State.OPPENDING; break; case OPPENDING: acc2 = compute(acc2, ops, v); ops = op; state = State.OPPENDING; senderg(acc2); Seite 43 Zahl und Operator verarbeiten

44 Taschenrechner : Model-Komponente / Java (1) void receivecomp(long v) { Zahl verarbeiten switch (state) { case OPWAIT: // kein Operator da: ignore break; case OPPENDING: acc2 = compute(acc2, ops, v); state = State.OPWAIT; senderg(acc2); Seite 44

45 Taschenrechner : Model-Komponente / Java (2) public void receivereset() { state = State.OPWAIT; acc2 = 0; reset private void senderg(long erg) { control.receiveerg(erg); private long compute(long v1, char op, try { switch (op) { case '+' : return case '-' : return case '*' : return case '/' : return catch ( ArithmeticException e) { control.receiveerror(); return 0; Hilfsroutine: Ergebnis an Control senden long v2) { v1+v2; v1-v2; v1*v2; v1/v2; Hilfsroutine: rechnen Seite 45

46 Taschenrechner: Zustandsorientierte Klassen mit (recht) komplexer Logik Entwurf vor Codierung! Logik auch einfacher Taschenrechner ist komplex! Entwurf mit Statecharts hilft beim Entwurf! Komplexes Zustände => Zustandsdiagramm vor Codierung welche Zustände hat ein Objekt welche Ereignisse treten auf welche Ereignisse in welchen Zuständen führen zu welchen Aktionen führen zu welchen neuen Zuständen Seite 46

47 GUI-s: weitere Info siehe Seite 47