Angemessene Reaktion: Abfertigung

Transkript

1 Angemessene Reaktion: Abfertigung Prinzip der Abfertigung Regeln gegen die Komplexität Symbolische Konstanten Abfertigung über Arrays Polymorphe Afertigung Callback

2 Grundstruktur Abfertigung (Dispatcher) Praktisch jedes Programm hat eine zentrale Abfertigung ("Eingangskontrolle") Grundstruktur: if (bedingung1) aktion1(); else if (bedingung2) aktion2(); else if (bedingung3)... Oft gibt es tiefer im Programm noch weitere solche Abfertiger. Abfertiger sind zentral für das Verständnis des Programms. Die Struktur ist oft nicht so einfach: schwierige kombinierte Bedingungen mehrstufige Fallunterscheidungen

3 Abfertigung Metapher Schalterhalle: Anstellen immer an der kürzesten Schlange Abfertigungsschalter mit unterschiedlichen Kompetenzen: D, EU, Int (je 2 D+EU, EU+Int) Abfertigungsstrategie: Reihum aus Schlangen entnehmen. Falls freie Kompetenz nicht passt, nächste Schlange. Gerecht??? Anstellen nach Nationalitäten Entnahme aus der Schlange mit der passenden Nationalität, möglichst im Wechsel.

4 Kontext class Zentrale { List <Queue<Person>> halle = new List<>(); List <Schalter> schalter = new List<>(); Schalter aktuellerschalter; int next;... class Schalter extends Queue<Person> { public Kompetenz kompetenz; public static boolean passt(nationalitaet, Kompetenz) {......

5 Abfertigungsstrategie public void dispatch() { for (int i=0: i<halle.size(); i++) { if (halle.get(next).size()!=0) break; next=(next+1)%halle.size(); if (halle.get(next).size()==0) return; if (Schalter.passt (halle.get(next).peek().nationalitaet, aktuellerschalter.kompetenz)) aktuellerschalter.add(halle.get(next).remove()); next=(next+1)%halle.size(); Wer versteht das??

6 Break und Continue break verlässt den innersten switch-, while- oder for-block die entsprechende Schleife wird beendet continue verlässt den aktuellen while- oder for-block die Schleife wird mit dem nächsten Durchgang fortgesetzt.

7 public void dispatch() { Übersicht bitte! int next = naechstenichtleereschlange(); if (istleer(next)) return; if (aktuellerschalteristzustaendig()) entnimmundbearbeite(); next = (next+1)%halle.size(); private boolean aktuellerschalteristzustaendig() { return Schalter.passt (halle.get(next).peek().nationalitaet, aktuellerschalter.kompetenz); private void entnimmundbearbeite() { aktuellerschalter.add(halle.get(next).remove());

8 Abfertigung als Exception-Zentrale Abfertiger sind typische Exception-Zentralen: Prüfen der Verteilungskriterien ggf. Exception werfen Fangen und Behandeln der Exceptions aus den Aktionen Grundstruktur: if (bedingung1) { try { aktion1(); catch (ActionException e) { /* Rep. oder Meldg. */ else if (bedingung2) try { aktion2(); catch (ActionException e) { /* Rep. oder Meldg. */ else throw new DispatchException();

9 Verständnis-Alarm Abweichungen von der Grundstruktur sind die Regel: Nicht-triviale Bedingungen, vielfach kombiniert und ineinander verschachtelt verwirrend häufige Fehlerquellen! Abhilfe durch Programmierstil! Zur Illustration genügt ein "harmloses" Beispiel...

10 Beispiel Taschenrechner Rechenwerk verarbeiteeingabe (char c) : String je nach Eingabe muss unterschiedlich verfahren werden: Dispatch!

11 Rechenwerk verarbeiteeingabe (char c) : String public void act() { char eingabe = RechnerGUI.naechsterButton(); verarbeiteeingabe(eingabe); private verarbeiteeingabe(char eingabe) { // ziffer anhängen und anzeigen // operator letzten operator ausführen; // zahl und operator speichern. // etc.

12 class Rechenwerk{ double zahl0 = 0; String zahl1 = ""; char op = '='; boolean bruch=false; Rechenwerk mit Dispatch public String verarbeiteeingabe (char c) { if (c>='0'&&c<='9'){ zahl1+=c; return zahl1; else { if (c=='.') { if (!bruch) { bruch = true; zahl1+=c; return zahl1; else return "error more than one decimal point"; else { if (c=='=' ( c>=42 && c<=47) ) { switch (op) { case '+': zahl0 += Double.parseDouble(zahl1); zahl1=""; break; case '-': zahl0 -= vielleicht richtig (??) aber grottenschlecht programmiert! Double.parseDouble(zahl1); zahl1=""; break; //etc... case '=': zahl0 = Double.parseDouble(zahl1); zahl1=""; break; default: return "error illegal operator"; op = c; else return "error invalid input";

13 Regeln gegen die Komplexität 1. Trenne Fallunterscheidung und Aktion! 2. Benenne die Aktionen durch Methoden! Rechnerstatus abf ertigen(char eingabe) Rechenwerk zif f er( ) operator( ) gleich( ) v orzeichen( ) dezimalpunkt( ) 3. Benenne die Fälle durch boolesche Funktionen! private boolean istziffer(char c); private boolean istoperator(char c); // etc.

14 4. Verwende kaskadiertes if! statt: if (a) aa; else /* also!a */ { if (b) bb; else /* also!a &!b */ { if (c) cc; else /* also!a &!b &!c */ dd; einfacher: if (a) aa; else if (b) bb; else if (c) cc; else dd; (analog switch) aa a bb "rechts-verzweigt" b cc c dd

15 Komplexitäts-reduzierte Abfertigung /** Bearbeitung eines Eingabezeiches: * Weiterleitung an die Rechenwerk-Methoden * Grundidee: * ziffer anhängen und Anzeigewert liefern * operator letzten operator ausführen; * zahl und operator speichern. * Anzeigewert liefern */ public String abfertigen(char eingabe) { if (istziffer(eingabe)) return werk.ziffer(eingabe); else if (istoperator(eingabe)) return werk.operator(eingabe); else if (istdezimalpunkt(eingabe)) return werk.dezimalpunkt(eingabe); else if (istgleich(eingabe)) return werk.gleich(eingabe); else return fehler(eingabe);

16 Vorsicht bei Seiteneffekten! Fallunterscheidung durch boolesche Funktionen (oder Ausdrücke) Seiteneffekt: die Abfragereihenfolge ist nicht beliebig (unlogisch!): private boolean istziffer() { return (schlange.entnehmen()>='0' && schlange.entnehmen()<='9'); // istoperator, istgleich entsprechend.. So etwas passiert Ihnen natürlich nicht... private abfertigen() { if (istziffer()) werk.ziffer(schlange.entnehmen()); else if (istoperator()) werk,operator(schlange.entnehmen()); // etc

17 Symbolische Konstanten Fallunterscheidung über eine kleine feste Menge von Alternativen Darstellbar als Symbolische Konstanten Beispiel: EtchASketch.GREEN EtchASketch.BLUE Symbolische Konstanten sind static final und typischerweise int-werte (nicht notwendig) Seit Java5 gibt es dafür auch Enumerationstypen

18 Beispiele für Symbolische Konstanten public static final int PLUS_KNOPF = 10, MINUS_KNOPF = 11, MAL_KNOPF = 12; java.awt.color.grey java.awt.borderlayout.center java.awt.component.bottom_alignment java.awt.label.right java.lang.math.pi // "echte" Konstante java.lang.double.nan Grundsätzlich alle Literale benennen, außer 0 und 1!

19 Symbolische Konstanten können mit == verglichen werden Sollten nicht in arithmetischen Ausdrücken vorkommen sind oft Bestandteil eines Interfaces Ab Java5 gibt es Enumerationen als Typ mit ähnlichen Eigenschaften, aber darüber sprechen wir ein anderes Mal.

20 Fallunterscheidung mit Symbolischen Konstanten Oft ist es sinnvoll, symbolischen Konstanten eine Textform zuzuordnen (analog tostring()) Schreiben wir eine statische Methode dafür: public static String tostring(int knopfid) { if (knopfid == Rechner.PLUS_KNOPF)return "+"; else if (knopfid == Rechner.Minus_KNOPF)return "-"; else if (knopfid == Rechner.MAL_KNOPF)return "*"; //... Beschriftung der Knöpfe ist dann ganz einfach: Button plusknopf = new Button(Rechner.toString(Rechner.PLUS_KNOPF)); Button minusknopf = new Button(Rechner.toString(Rechner.MINUS_KNOPF));

21 Fallunterscheidung Array-Indizes Wir können das klasseninterne Wissen über die int- Kodierung der Tasten nutzen, um die Textdorm in einem Array zu speichern: static String[] tastentext = { "0","1","2","3", "4","5","6","7", "8","9","+","-",... ; Dann können wir die symbolischen Konstanten zur Indizierung nutzen: hier wird das Geheimnisprinzip wichtig! Button achtbutton = new Button(Rechner.tastentext[Rechner.ACHT_KNOPF]);

22 Fallunterscheidung ohne Abfrage Die Indizierung macht die Abfertigung einer Taste möglich, ohne dabei die Taste "anzusehen" d.h. Fallunterscheidung ohne Abfrage: class Rechner { class public Rechner void { tasteausgeben(int tastenid) { switch (tastenid) { public void case tasteausgeben(int PLUS_KNOPF: tastenid) { ausgeben(tastentext[tastenid]) ausgeben(tastentext[plus_knopf]); break; case MINUS_KNOPF: ausgeben(tastentext[minus_knopf]); break; //...

23 "Übertragbares Verhalten" Weiter im BeispielTaschenrechner: Jeder Taste ist eine Reaktion zugeordnet Bisher kennen wir Verteiler über if, switch oder Array Neuer Ansatz: Verhaltenskapsel Objekte "wissen" selbst, wie sie sich verhalten sollen Verhalten kann Objekten zu Laufzeit zugeordnet werden gekapselt in ein Objekt.

24 Polymorphe Abfertigung Interface Tastenbehandler mit drei Implementierungen: Zifferntaste Operatortaste Cleartaste Gemeinsame Methode tastegedrueckt()

25 Fallunterschiedung über Typen if (taste instanceof Zifferntaste) ((Zifferntaste)taste).tasteGedrueckt(); else if (taste instanceof Operatortaste) ((Operatortaste)taste).tasteGedrueckt(); else if ((taste instanceof Cleartaste) ((Cleartaste)taste).tasteGedrueckt(); else /* kann nicht sein */; Polymorphie ersetzt die Fallunterscheidung taste.tastegedrueckt();

26 Taschenrechner mit gekapseltem Verhalten gekapseltes Verhalten liesnaechstetaste() Rechner (AnimateObject) tastegedrueckt RechnerGui Tastenbehandler Ziffern -taste Operatortaste Cleartaste

27 Rechner -Überblick Der Rechner macht immer dasselbe: Taste von der Gui lesen Taste verarbeiten durch Rufen der Methode tastegedrueckt() eines Tastenbehandlers Trotzdem passiert Unterschiedliches: verschiedene Tastenbehandler implementieren "tastegedrueckt" verschieden Polymorphie Tastenbehandler kapseln Verhalten Verhalten kann dynamisch zugeordnet werden Erforderlich: ein Interface - als Vertrag über die Methodensignatur

28 Rechner Gekapseltes Verhalten interface Tastenbehandler { tastegedrueckt(rechner rechner); class Zifferntaste implements Tastenbehandler { final int wert; Zifferntaste(int wert) { this.wert = wert; void tastegedrueckt(rechner rechner) { rechner.anhaengen(wert); class Operatortaste implements Tastenbehandler { /* analog */ class Cleartaste implements Tastenbehandler { /* analog */

29 Rechner Codegerüst: Handler-Array initialisieren class Rechner extends AnimateObject { RechnerGUI gui = new RechnerGUI(); Tastenbehandler[] tasten = new Tastenbehandler[]; Rechner() { // Dispatch-Array einrichten: for (int i=0; i<10; i++) tasten[i] = new Zifferntaste(i); for (int i=rechner.plus_taste; i<rechner.gleich_taste; i++) tasten[i] = new Operatortaste(i); tasten[rechner.clear_taste] = new ClearTaste();

30 Rechner Codegerüst: Polymorphe Bearbeitung public class Rechner implements Animate { private RechnerGUI gui; private Tastenbehandler[] tasten; void act() { int tastencode = -1; try { tastencode = gui.liesnaechstetaste(); tasten[tastencode].tastegedrueckt(this); catch (KeineTasteException e) { /* ignorieren */ polymorph!

31 Ein Standard-Interface Animate aus cs101 hat eine parameterlose Methode: act() kann zur Verhaltenskapselung benutzt werden auch ohne Thread: void bearbeite(animate technik){ technik.act(); // polymorph! Ebenso eignet sich das Interface Runnable aus java.lang es definiert die Methode run(): void bearbeite(runnable technik){ technik.run(); // polymorph!

32 Callback liesnaechstetaste() Rechner (AnimateObject) tastegedrueckt(rechner r) RechnerGui anhaengen() ausrechnen() neueaufgabe() Tastenbehandler Ziffern -taste Operatortaste Cleartaste void tastegedrueckt(rechner rechner) { rechner.anhaengen(wert);

33 Callback Callback bedeutet, dass die gerufene Methode ihren Aufrufer "zwischendurch" kontaktieren will. Dazu muss sie den Aufrufer "kennen" d.h. eine Referenz auf ihn besitzen. - Technik: Der Aufrufer gibt sie als Parameter mit. Sie muss aber auch den Typ des Aufrufers kennen! - Technik: oft implementiert der Aufrufer ein Interface

34 ... genug für diesmal! Üben Sie Abfertigung in Nodenet das Callback-Prinzip brauchen wir für GUIs