Java lernen durch Ausprobieren!

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Zuletzt angesehen:
klassen2:interfaces:start

Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.


—klassen2:interfaces:start [2024/08/31 10:03] (aktuell) – angelegt - Externe Bearbeitung 127.0.0.1
Zeile 1: Zeile 1:
 +====== Interfaces ======
 +{{ youtube>dn6FT_g8OZk?large }}
 +Stellen wir uns ein Bibliotheksprogramm vor, das verschiedene Listen ausgeben kann:
 +  * eine Liste aller Bücher der Bibliothek
 +  * eine Liste aller Ausleiher/innen 
 +  * eine Liste aller säumigen Ausleiher/innen
 +  * usw.
 +Das Bibliotheksprogramm wird eine Klasse ''Listenausgabe'' haben, die für jede der obigen Listen eine Methode besitzt. \\ 
 +Von einem guten Programm würden wir erwarten, dass es diese Listen auf dem Bildschirm, als pdf-Datei, als Html-Datei oder als csv-Datei (zur Verwendung in Tabellenkalkulationen) ausgeben kann. Es müsste also jede der obigen Methoden mehrfach geben:
 +  * eine Liste aller Bücher der Bibliothek //auf dem Bildschirm// ausgeben
 +  * eine Liste aller Bücher der Bibliothek //als pdf-Datei// ausgeben
 +  * eine Liste aller Bücher der Bibliothek //als Html-Datei// ausgeben
 +  * eine Liste aller Bücher der Bibliothek //als csv-Datei// ausgeben  
 +  * eine Liste aller Ausleiher/innen //auf dem Bildschirm// ausgeben
 +  * eine Liste aller Ausleiher/innen //als pdf-Datei// ausgeben
 +  * eine Liste aller Ausleiher/innen //als Html-Datei// ausgeben
 +usw. \\ \\ 
 +<WRAP center round tip 60%>
 +Ist es wirklich nötig, für jede Ausgabemöglichkeit jede der Listenmethoden erneut zu schreiben? Der Programmcode der ersten vier Methoden wird doch größtenteils identisch sein, ebenso der der nächsten vier Methoden usw.! \\ \\ 
 +**Klar geht es einfacher:** Für solche Zwecke verwenden wir **Interfaces**.
 +</WRAP>
 +
 +
 +===== Bibliotheksprogramm: interface Ausgeber =====
 +Die Lösung des obigen Problems besteht in der Trennung der Aufgaben ([[https://en.wikipedia.org/wiki/Separation_of_concerns|separation of concerns]]): Das Bibliotheksprogramm besitzt eine Klasse ''Listengenerator'', die zur Ausgabe jeder Listenart (Bücherliste, Ausleiherliste, ...) je eine Methode besitzt. Dieser Klasse stellen wir ein Objekt (im folgenden kurz: Ausgabeobjekt) zur Verfügung, das sich darum kümmert, in welcher **Form** die Listen ausgegeben werden (auf dem Bildschirm, als pdf-Datei, ...). Damit die Methoden der Klasse Listengenerator dieses Ausgabeobjekt nutzen können, müssen sie "wissen", welche Methoden es besitzt. Diese Vereinbarung wird in einem Interface getroffen:
 +<code learnj>
 +interface Ausgeber {
 +   void schreibeZellwert(String wert);
 +   void neueZeile();
 +}
 +</code>
 +<WRAP center round info 60%>
 +Ein **interface** ist eine Vereinbarung darüber, welche Methoden eine Klasse mindestens besitzen soll. Im Interface werden die Methoden nur deklariert, d.h. es wird angegeben, welchen Bezeichner ( = Namen) sie tragen, welche Parameter sie benötigen und welchen Datentyp ihr Rückgabewert hat. Der Methodenrumpf (d.h. die Anweisungen in ''{'' ... ''}'') wird weggelassen. Jede Methodendeklaration in einem Interface wird durch ein Semikolon ('';'') abgeschlossen.
 +</WRAP>
 +In unserem Fall erwarten wir vom Ausgabeobjekt, dass es Tabellen ausgeben kann. Dazu besitzt es eine Methode zur Ausgabe von Text in einer Tabellenzelle und eine Methode, um eine neue Tabellenzeile zu beginnen. \\ 
 +
 +===== Bibliotheksprogramm: Implementierungsvarianten des Interfaces =====
 +Mit dem Interface alleine kann man nichts anfangen, denn es besitzt noch keinen Programmcode, der die Aufgaben wirklich erledigen kann. Wir müssen Klassen schreiben, die genau die Methoden besitzen, die das Interface definiert. Man sagt: Diese Klassen **implementieren** das Interface. Wir beginnen mit einer Klasse, die eine Tabelle auf dem Bildschirm ausgeben kann:
 +<HTML>
 +
 +<div class="java-online" style="height: 400px; width: 100%" data-java-online="{'id': 'Interfaces1', 'withBottomPanel': true}">
 +
 +<script type="text/plain" title="BildschirmAusgeber.java">
 +class BildschirmAusgeber implements Ausgeber {
 +   void schreibeZellwert(String wert) {
 +      print(wert + " ");
 +   }
 +   void neueZeile() {
 +      println();
 +   }
 +}
 +</script>
 +<script type="text/plain" title="Ausgeber.java">
 +interface Ausgeber {
 +   void schreibeZellwert(String wert);
 +   void neueZeile();
 +}
 +</script>
 +
 +</div>
 +
 +</HTML>
 +
 +Die Festlegung ''implements Ausgeber'' in Zeile 1 bedeutet: "Die Klasse ''Bildschirmausgeber'' besitzt alle im Interface ''Ausgeber'' definierten Methoden. Lösche im oberen Beispiel mal eine der beiden Methoden der Klasse ''Bildschirmausgeber'' raus und schau' Dir an, was passiert!
 +
 +==== Weitere Implementierungsvarianten ====
 +Wir schreiben weitere Klassen, die das Interface implementieren:
 +
 +<HTML>
 +
 +<div class="java-online" style="height: 400px; width: 100%" data-java-online="{'id': 'Interfaces2', 'withBottomPanel': true}">
 +
 +<script type="text/plain" title="BildschirmAusgeber.java">
 +class BildschirmAusgeber implements Ausgeber {
 +   void schreibeZellwert(String wert) {
 +      print(wert + " ");
 +   }
 +   void neueZeile() {
 +      println();
 +   }
 +}
 +</script>
 +<script type="text/plain" title="HtmlAusgeber.java">
 +class HtmlAusgeber implements Ausgeber {
 +   boolean zeileBegonnen = false;
 +   
 +   void schreibeZellwert(String wert) {
 +      if(!zeileBegonnen) print("<tr>");
 +      zeileBegonnen = true;
 +      print("<td>" + wert + "</td>");
 +   }
 +   void neueZeile() {
 +      println("</tr>");
 +      zeileBegonnen = false;
 +   }
 +}
 +</script>
 +<script type="text/plain" title="CSVAusgeber.java">
 +class CSVAusgeber implements Ausgeber {
 +   void schreibeZellwert(String wert) {
 +      print("\"" + wert + "\"; ");
 +   }
 +   void neueZeile() {
 +      println();
 +   }
 +}
 +</script>
 +<script type="text/plain" title="Ausgeber.java">
 +interface Ausgeber {
 +   void schreibeZellwert(String wert);
 +   void neueZeile();
 +}
 +</script>
 +
 +</div>
 +
 +</HTML>
 +
 +===== Bibliotheksprogramm: Listengenerator =====
 +Der Listengenerator soll mit jeder der obigen Ausgabeklassen zusammenarbeiten können. Wir geben ihm daher ein Attribut ''ausgeber'' vom Typ ''Ausgeber''. Dieses Attribut kann auf beliebige Objekte zeigen, die das Interface ''Ausgeber'' implementieren. Daher lassen sich mit diesem Attribut nur diejenigen Methoden aufrufen, die das Interface ''Ausgeber'' definiert. \\ Be
 +Wir lassen das Attribut ''ausgeber'' zuerst auf ein Objekt der Klasse ''Bildschirmausgeber'' zeigen und rufen die Methode ''schreibeBücherListe()'' auf. Anschließend wiederholen wir dasselbe mit den beiden anderen Ausgeber-Klassen. 
 +<HTML>
 +
 +<div class="java-online" style="height: 600px; width: 100%" data-java-online="{'id': 'Interfaces3', 'withBottomPanel': true}">
 +
 +<script type="text/plain" title="Listengenerator.java">
 +Listengenerator bp = new Listengenerator();
 +bp.setzeAusgeber(new BildschirmAusgeber());
 +bp.schreibeBücherListe();
 +println();
 +
 +bp.setzeAusgeber(new HtmlAusgeber());
 +bp.schreibeBücherListe();
 +println();
 +
 +bp.setzeAusgeber(new CSVAusgeber());
 +bp.schreibeBücherListe();
 +println();
 +
 +
 +
 +class Listengenerator {
 +
 +   Ausgeber ausgeber;
 +
 +   void setzeAusgeber(Ausgeber ausgeber) {
 +      this.ausgeber = ausgeber;
 +   }
 +
 +   void schreibeBücherListe() {
 +      ausgeber.schreibeZellwert("Astrid Lindgren");
 +      ausgeber.schreibeZellwert("Pippi Langstrumpf");
 +      ausgeber.neueZeile();
 +      ausgeber.schreibeZellwert("Terry Pratchett");
 +      ausgeber.schreibeZellwert("Eine Insel");
 +      ausgeber.neueZeile();
 +   }
 +
 +}
 +</script>
 +<script type="text/plain" title="BildschirmAusgeber.java">
 +class BildschirmAusgeber implements Ausgeber {
 +   void schreibeZellwert(String wert) {
 +      print(wert + " ");
 +   }
 +   void neueZeile() {
 +      println();
 +   }
 +}
 +</script>
 +<script type="text/plain" title="HtmlAusgeber.java">
 +class HtmlAusgeber implements Ausgeber {
 +   boolean zeileBegonnen = false;
 +   
 +   void schreibeZellwert(String wert) {
 +      if(!zeileBegonnen) print("<tr>");
 +      zeileBegonnen = true;
 +      print("<td>" + wert + "</td>");
 +   }
 +   void neueZeile() {
 +      println("</tr>");
 +      zeileBegonnen = false;
 +   }
 +}
 +</script>
 +<script type="text/plain" title="CSVAusgeber.java">
 +class CSVAusgeber implements Ausgeber {
 +   void schreibeZellwert(String wert) {
 +      print("\"" + wert + "\"; ");
 +   }
 +   void neueZeile() {
 +      println();
 +   }
 +}
 +</script>
 +<script type="text/plain" title="Ausgeber.java">
 +interface Ausgeber {
 +   void schreibeZellwert(String wert);
 +   void neueZeile();
 +}
 +</script>
 +
 +</div>
 +
 +</HTML>
 +
 +<WRAP center round tip 60%>
 +Im Beispiel oben gibt es nur eine **einzige** Methode ''schreibeBücherListe()'', die sich nicht darum kümmern muss, in welcher Form ihre Ausgabe ausgegeben wird. Wir rufen sie dreimal auf und erhalten drei unterschiedlich formatierte Ausgaben, indem wir einfach nur jedesmal ein anderes Objekt zur Verfügung stellen, das das Interface ''Ausgeber'' implementiert.
 +</WRAP>
 +
 +===== Klassendiagramm =====
 +{{ :klassen2:interfaces:klassendiagramm_interfaces.png?600 |}}
 +Ein Interface sieht im UML-Diagramm aus wie eine Klassenkarte, der Bezeichner ist jedoch kursiv geschrieben und durch ein vorangestelltes //<<interface>>// als solches gekennzeichnet. Dass eine Klasse ein Interface implementiert, kennzeichnet man im UML-Diagramm durch eine gestrichelte Verbindungslinie, die beim Interface in ein Dreieck mündet.
 +
 +===== Aufgabe 1 =====
 +Schreibe eine Klasse ''JSonAusgeber'', die das Interface ''Ausgeber'' implementiert und Tabellen im [[https://en.wikipedia.org/wiki/JSON|JSon-Format]] als Liste ausgibt, also so:
 +<code javascript>
 +[ 'Zeile1, Spalte1', 'Zeile1, Spalte2' ],
 +[ 'Zeile2, Spalte1', 'Zeile2, Spalte2' ]
 +</code>
 +====== Anwendung: Timer ======
 +<WRAP center round info 60%>
 +Wenn Du möchtest, dass eine Methode periodisch nach immer gleichen Zeitabständen aufgerufen wird, kannst Du dafür die ''Timer''-Klasse benutzen. Die Methode
 +<code java>
 +   Timer.repeat(runnable, deltaTimeInMs);
 +</code> 
 +bekommt als Parameter ein Objekt übergeben, das das Interface ''Runnable'' implementiert und damit gesichert eine Methode ''run()'' besitzt:
 +<code java>
 +interface Runnable{
 +
 +  public void run();
 +
 +}
 +</code>
 +Diese Methode wird von der Klasse ''Timer'' nach jeweils ''deltaTimeInMs'' Millisekunden immer wieder aufgerufen.
 +</WRAP>
 +
 +
 +<HTML>
 +
 +<div class="java-online" style="height: 300px; width: 100%" data-java-online="{'withBottomPanel': false, 'id': 'InterfacesTimer'}">
 +
 +<script type="text/plain" title="TimerExample.java">
 +Timer.repeat(new Zähler(), 500);
 +
 +class Zähler implements Runnable {
 +   
 +   int n = 1;
 +
 +  public void run() {
 +           SystemTools.clearScreen();
 +           println(n + "-ter Aufruf!");
 +           n++;
 +  }
 +
 +}
 +</script>
 +
 +</div>
 +
 +</HTML>
 +
 +===== Aufgabe 2 =====
 +Schreibe ein Programm, dass ständig die seit dem Programmstart vergangene Zeit in Minuten und Sekunden (Beispiel: 03:12) anzeigt. \\ 
 +//Tipp: Die Methode ''SystemTools.clearScreen()'' löscht den Textausgabebereich.//
 +
 +====== Flächenberechnung mittels Monte-Carlo-Simulation ======
 +{{ :klassen2:interfaces:pasted:20200521-225753.png}}
 +{{:klassen2:interfaces:monte-carlo_1.png?400 |}}
 +Wir wollen Inhalte ebener, begrenzter Flächen mithilfe der Monte-Carlo-Simulation berechnen. Am Beispiel der Fläche des Einheitskreises (Kreis um den Punkt (0,0) mit Radius 1) erkläre ich Dir, wie das geht.
 +== 1. Schritt: Wir umgeben die Fläche mit einem achsenparallelen Rechteck ==
 +{{ :klassen2:interfaces:monte-carlo_2.png?400|}}
 +In diesem Fall wählen wir das Rechteck, das von $x_{min} = -1$, $x_{max} = 1$, $y_{min} = -1$ und $y_{max} = 1$ begrenzt ist.
 +
 +== 2. Schritt: Wir platzieren sehr viele zufällige Punkte ins Rechteck ==
 +Wie das aussieht, siehst Du an der Grafik rechts oben. Ein Teil der Punkte liegt in der zu bestimmenden Fläche (grün), ein Teil außerhalb (rot). 
 +
 +== 3. Schritt: Flächenberechnung ==
 +Angenommen, wir haben 10000 Punkte gesetzt, davon liegen 7894 im Einheitskreis. Dann lässt sich ein guter Näherungswert für seinen Flächeninhalt so berechnen:
 +$$ Fläche_{Kreis} = \frac{Fläche_{Rechteck}}{10000} \cdot 7894  = \frac{(x_{max} -x_{min}) \cdot (y_{max} -y_{min})}{10000}\cdot 7894 = \frac{4}{10000}\cdot 7894 \approx 3,1576$$
 +
 +== 4. Schritt: Punktezahl erhöhen ==
 +Da die Punkte zufällig gewählt sind, ergibt sich bei jedem Programmablauf ein anderer Wert für die Kreisfläche. Dieser nähert sich bei zunehmender Punktezahl aber mit immer größerer Wahrscheinlichkeit immer mehr dem exakten Wert ($\pi\cdot r^2 = \pi\cdot 1^2\approx 3,141592$) an. Meldung eines beispielhaften Programmablaufs:
 +  * Nach 10000 Schritten liegen 7839 Punkte in der Fläche. Näherungswert nach 10000 Schritten: 3.1356
 +  * Nach 20000 Schritten liegen 15674 Punkte in der Fläche. Näherungswert nach 20000 Schritten: 3.1348000000000003
 +  * Nach 30000 Schritten liegen 23431 Punkte in der Fläche. Näherungswert nach 30000 Schritten: 3.1241333333333334
 +  * Nach 40000 Schritten liegen 31303 Punkte in der Fläche. Näherungswert nach 40000 Schritten: 3.1303
 +  * Nach 50000 Schritten liegen 39170 Punkte in der Fläche. Näherungswert nach 50000 Schritten: 3.1336000000000004
 +
 +==== Programm ====
 +Die Klasse ''Flächenberechner'' verfügt über eine Methode ''berechneFlächenInhalt(Fläche fläche)'', die Mittels der Monte-Carlo-Methode den Flächeninhalt der als Parameter übergebenen Fläche berechnen kann. Aber wie soll so ein ''Fläche''-Objekt beschaffen sein, d.h. welche Methoden soll es haben? \\ 
 +Überlegen wir, was wir zur Durchführung der Monte-Carlo-Methode benötigen:
 +  * Wir müssen ein achsenparalleles Rechteck um die Fläche ziehen, brauchen also die Werte $x_{min}$, $x_{max}$, $y_{min}$ und $y_{max}$. 
 +  * Für jeden der zufällig bestimmten Punkte im Rechteck müssen wir wissen, ob er in der zu messenden Fläche liegt oder nicht.
 +Diese Anforderungen formulieren wir als Interface:
 +<code java>
 +interface Fläche {
 +   public boolean punktLiegtDrin(double x, double y);
 +   public double getXMin();
 +   public double getXMax();
 +   public double getYMin();
 +   public double getYMax();
 +}
 +</code>
 +
 +Wir schreiben eine Klasse Einheitskreis, die das Interface implementiert und dem Einheitskreis entspricht. 
 +<WRAP center round tip 60%>
 +**Erinnerung: ** \\ Ein Punkt $(x, y)$ liegt genau dann im Einheitskreis, wenn $\sqrt{x^2 + y^2} \le 1$, also wenn $x^2 + y^2 \le 1$.
 +</WRAP>
 +
 +
 +<HTML>
 +
 +<div class="java-online" style="height: 600px; width: 100%" data-java-online="{'id': 'Interfaces4', 'withBottomPanel': true}">
 +
 +<script type="text/plain" title="Einheitskreis.java">
 +Flächenberechner fb = new Flächenberechner();
 +fb.berechneFlächenInhalt(new Einheitskreis());
 +
 +
 +class Einheitskreis implements Fläche {
 +   public boolean punktLiegtDrin(double x, double y) {
 +      return x * x + y * y <= 1;
 +   }
 +
 +   public double getXMin() {
 +      return -1;
 +   } 
 +
 +   public double getXMax() {
 +      return 1;
 +   } 
 +
 +   public double getYMin() {
 +      return -1;
 +   } 
 +
 +   public double getYMax() {
 +      return 1;
 +   } 
 +
 +}
 +
 +interface Fläche {
 +   public boolean punktLiegtDrin(double x, double y);
 +   public double getXMin();
 +   public double getXMax();
 +   public double getYMin();
 +   public double getYMax();
 +}
 +</script>
 +<script type="text/plain" title="Flächenberechner.java">
 +public class Flächenberechner {
 +
 +   private Bitmap bitmap;           // Zeichenobjekt, in dem einzelne Pixel gefärbt werden können
 +   private int pixelZahl = 200;     // Nur zum Zeichnen: Anzahl der Pixel in horizontaler und vertikaler Richtung
 +   
 +   private double zeichenFaktor;    // Pixel pro Einheit des Koordinatensystems
 +   private double xMin;             // Linker Rand des umgebenden Rechtecks
 +   private double yMin;             // Rechter Rand des umgebenden Rechtecks
 +   
 +   public void berechneFlächenInhalt(Fläche fläche) {
 +      
 +      double rechtecksBreite = fläche.getXMax() - fläche.getXMin();
 +      double rechtecksHöhe = fläche.getYMax() - fläche.getYMin();
 +      
 +      initGraphik(fläche, rechtecksBreite, rechtecksHöhe);
 +      
 +      double drin = 0;
 +      double flächeUmgebendesRechteck = rechtecksBreite * rechtecksHöhe;
 +
 +      for(int n = 1; n <= 500000; n++) {
 +         
 +         // zufällige Zahl zwischen xMin und xMax
 +         double x = Math.random() * rechtecksBreite + fläche.getXMin();
 +
 +         // zufällige Zahl zwischen yMin und yMax
 +         double y = Math.random() * rechtecksHöhe + fläche.getYMin();
 +
 +         if(fläche.punktLiegtDrin(x, y)) {
 +            drin++;                                  // Erhöhung um 1
 +            zeichnePunkt(x, y, Color.green);
 +         } else {
 +            zeichnePunkt(x, y, Color.red);
 +         }
 +         
 +         // Nach je 10000 Punkten Ausgabe des Zwischenstands:
 +         if(n % 10000 == 0) {
 +            
 +            double näherungswert = flächeUmgebendesRechteck / n * drin;
 +            
 +            println("Von " + n + " Punkten liegen " + drin + " Punkte in der Fläche.");
 +            print("Näherungswert nach " + n + " Schritten: ", Color.gray);
 +            println(näherungswert, Color.lightblue);
 +            
 +         }
 +
 +      }
 +
 +   }
 +   
 +   private void initGraphik(Fläche fläche, double dx, double dy) {
 +      new World(1000, 1000);
 +      double dMax = dx; 
 +      if(dy > dx) dMax = dy;
 +      bitmap = new Bitmap(pixelZahl, pixelZahl, 0, 0, 1000, 1000);
 +      
 +      zeichenFaktor = pixelZahl / dMax;
 +      xMin = fläche.getXMin();
 +      yMin = fläche.getYMin();
 +
 +      bitmap.fillAll(Color.black);
 +   }
 +   
 +   private void zeichnePunkt(double x, double y, Color color) {
 +      
 +      int ix = Math.round((x - xMin) * zeichenFaktor);
 +      int iy = pixelZahl - Math.round((y - yMin) * zeichenFaktor);
 +
 +      bitmap.setColor(ix, iy, color);
 +
 +   }
 +
 +}
 +</script>
 +
 +</div>
 +
 +</HTML>
 +<WRAP center round tip 60%>
 +**Tipp:** Lass' das Programm mit sehr höher Geschwindigkeit ablaufen, sonst dauert es ewig, bis Du etwas siehst.
 +</WRAP>
 +
 +
 +===== Aufgabe 3 (freiwillig) =====
 +Übernimm den Code für das Interface ''Fläche'' und die Klasse ''Flächenberechner'' und programmiere dazu
 +  * a) Eine Klasse Dreieck, die das Dreieck mit den Eckpunkten $(0,0)$, $(0,1)$ und $(1,0)$ repräsentiert.
 +  * b) Eine Klasse Sinus, die dem Flächenstück unter dem ersten "Buckel" der Sinusfunktion entspricht. \\ Berechne mit Hilfe dieser beiden Klassen näherungsweise den jeweiligen Flächeninhalt.
 +  * c) Für die Interessierten: Versuche, die Klasse ''Flächenberechner'' zu verstehen!
 +
 +<WRAP center round info 60%>
 +Das Monte-Carlo-Verfahren verwendet man in der Praxis natürlich nicht für so einfache ebene Flächen wie die Beispiele oben, sondern nur zur Berechnung des Flächeninhalts komplex gestalteter Flächen in mehrdimensionalen Räumen.
 +</WRAP>
 +[[.loesung:start|Hier geht's zur Lösung.]]