Grundlagen der Informatik 1

Grundlagen der Informatik 1 Thema 13: Vererbung, Funktionsvorlagen, Späte Bindung Prof. Dr. Max Mühlhäuser Dr. Guido Rößling

Inhaltsverzeichnis • Wozu Vererbung? • Inkrementelles Programmieren • Definition neuer Objekttypen in Java • Grundlagen des Packageacm.graphics • Modellierung eines Grafiksystems • Abstrakte Klassen • Schnittstellen • Überschreiben bestehender Definitionen • Späte Bindung der Methodenimplementierungen beim Operationsaufruf

Wozu Vererbung? • In T12 haben wir eine Begriffshierarchie definiert • Kunde und Mitarbeiter sind spezielle Personen • Manager und Verwalter sind wiederum spezielle Mitarbeiter • Einfamilienhaus und Mehrfamilienhaus sind ein spezielles Haus • Die Oberbegriffe (Haus, Person) haben bestimmte Eigenschaften, die alle Unterbegriffe ebenfalls haben • Person: z.B. Name, Vorname, Telefonnummer, … • Mitarbeiter: Büro • Haus: Anschrift, Kaufpreis, Status, … • Wir wollen das in Java ebenfalls nutzen • Attribute wie die obigen sollen nicht mehrfach definiert werden • Gemeinsame Methoden sollen nur einmal implementiert werden • setName(String), setGivenName(String), setPhoneNumber(String),…

Motivation für neue Objekttypen • Die Klasse Person steht für allgemeine Personen • Im Kontext der Immobilienverwaltung können wir erst mit konkreten Personen arbeiten, die eine Funktion haben • Die also Manager, Verwalter oder Kunden sind • Wir wollen aber nicht immer konkret sagen, welche Art Person wir erwarten • MethodegetPhoneNumber(Person p) hängt nicht davon ab, welche Art Person wir haben • Wir wollen diese Methode nicht mehrfach implementieren • Hier soll „jede Art Person“ zum Typ Person passen! • Gleichzeitig haben die Untertypen spezielle Funktionen • getListOfManagedClients() vs. getListOfHouses() etc.

Vereinbarkeit verschiedener Klassen • Mitarbeiter, Verwalter, Kunde, … sind eigene Klassen • Um die unterschiedliche Funktionalität sauber zu realisieren • Dennoch sollen sie wo nötig „zu Person passen“ ( getName()) • Gemeinsame Methoden nur einmal implementieren • Vermeidet Redundanz im Code • Reduziert die Anzahl der Fehlerquellen • Verbessert die Wartbarkeit und Wiederverwendbarkeit • Passendes Konzept: Vererbung • Wir sagen „Klasse Mitarbeiter erbt von Klasse Person“ • Oder kürzer: Mitarbeiter erbt von Person

Grundregeln der Vererbung I • Regel 1: Vererbung beschreibt eine Spezialisierung • Der Erbeist eine speziellere Form seines Vorfahren • Ein Kunde ist eine spezielle Person • Umgekehrt ist der Vorfahr eine Verallgemeinerung seiner Erben • Eine Person ist eine Verallgemeinerung für Kunde, Mitarbeiter, … • Regel 2: Vererbung beschreibt eine „ist-ein“ Beziehung • Ein Kundeist eine (spezielle Art) Person • Ein Mehrfamilienhausistein (spezielles) Haus • Vererbung ist keine„hat-ein“ Beziehung! • Ein Kundehat ein (oder mehr als ein) Haus • Ein Kundeist aber keinHaus • Für hat ein verwenden wir Attribute: die Klasse Kunde hat als Attribut eine Liste von Häusern

Grundregeln der Vererbung II • Regel 3: Eine Klasse erbtalle Methoden und Attribute ihres Vorfahren • Sie kann weitere Methoden oder Attribute definieren • So hat ein Mitarbeiter noch eine Büronummer, die Person nicht hat • Regel 4: Geerbte Methoden können neu definiertwerden • Die Implementierung der Methode wird dabei überschrieben • Mehr dazu später in diesem Foliensatz • Regel 5: Das grundsätzliche Verhalten des Erben in einer geerbten Methode sollte zu dem des Vorfahren passen • „Unerwünschte“ Methoden kann man nicht „wegdefinieren“ • Man sollte sie auch nicht durch Überschreiben mit leerem Körper („mache nichts“) „anpassen“ • Beispiel: Kunde liefert bei getGivenName() immer nur null • Die Abfrage des Vornamens einer Person kann nun Probleme erzeugen

Unser Ziel: Neue Objekttypen • Wir beschäftigen uns im Folgenden mit neuen Objekttypen • Definition neuer Typen von Objekten • Erzeugung und Benutzung neuer Instanzen (Objekte, Exemplare) dieser Typen • Spezifikation allgemeiner Typen ohne direkte Funktionalität • Anpassen geerbter Methoden durch Überschreiben

Motivation für neue Objekttypen • Motivation / Vorteile: • Komplexere Aktionen pro Befehl • Nähe zur natürlichen Sprache • Einfacher zu verstehen und ggf. zu korrigieren niedriger Abstraktions-versatz Mentales Modell Design Modell schmale Repräsentations-Lücke Compiler Maschinenebene modulare Struktur des Programms

Spezifikation neuer Objekttypen • Neue Objekttypen werden inkrementelldefiniert • Über ihre Unterschiede zu existierenden Typen •  Spezialisierungvon generelleren Konzepten • Ein Manager ist eine spezielle Art Angestellter • Anderer Ansatz: Gemeinsamkeitenverschiedener Objekttypen in einen gemeinsamen Super-Typ abstrahieren • Übergeordnete / Untergeordnete Konzepte • Rechtecke und Dreiecke sind untergeordnete Konzepte von grafischen Objekten (können z.B. gezeichnet werden) Eine neue Programmkomponente N wird konstruiert, indem man spezifiziert, wie sie sich von einer bestehenden Komponente B unterscheidet, ohne B dabei zu modifizieren.

Inkrementelles Programmieren: Analogie Übereinander liegende Folien B N Stellen Sie sich vor, Sie haben die Folie B (Basis) auf dem Projektor und wollen daraus die Figur der Folie N (Neu) konstruieren, ohne dabei die Figur in B zu zerstören. Dafür würden Sie Folie M (Modifizierung) darüber legen. M • Am Ende gibt es sowohl B als auch N. • Durch Auflegen von M wird B nur „virtuell“ (nicht physisch) modifiziert.

B N M Inkrementelles Programmieren: Analogie Vorteile • Arbeit- / Kostenminimierung: • Nur die Differenz muss neu gezeichnet werden. B wird wieder verwendet. • Fehlervermeidung: B ist benutzt und getestet worden. Beim Neu-Zeichnen könnten Fehler entstehen. • Ähnliche Vorteile erwarten wir von der inkrementellen Programmierung in der Softwareentwicklung: • Software ist teuer. Wiederholte Entwicklung ist zu aufwändig. • Wiederverwendbarkeit ist ein wichtiges Thema in der Softwareindustrie.

Sprachunterstützung fürinkrementelles Programmieren • Notwendige Sprachkonstrukte: Definition neuer Klassen als Erben existierender Klassen durch Vererbung  das wahre neue Konzept von OOP • Definition neuer Operationen und/oder Instanzvariablen • Überschreiben von ererbten Operationen (Verhalten)

Definition neuer Objekttypen in Java: Person publicclass Person extendsObject{ String name; String givenName; String address; String phoneNr; // Konstruktorfor Person objects public Person(String pName, String pGivenName, String pAddress, String pPhone) { name = pName; givenName = pGivenName; address = pAddress; phoneNr = pPhoneNr; } public String getName() { // returnsthePerson‘sname returnname; } // MethodsgetGivenName(), setName(String) etc. } Schlüsselwort für Vererbung

Definition neuer Objekttypen in Java class<Subklasse> extends <Basisklasse> { [Liste neuer Attribute] [Liste von Konstruktoren] [Liste neuer Methoden] } Die neue Klasse „erbt“ alle Methoden und Attribute der Basisklasse und kann zusätzlich neue definieren. classClient extendsPerson { // ... } Ein Client ist zunächst mal eine Person. Er hat alle Eigenschaften und bietet alle Dienste einer Person an.

public class Client extends Person { House house; // only one house for now... publicClient(String name, String givenName, String address, String phone, House house) { setName(name); setGivenName(givenName); setAddress(address); setPhoneNumber(phone); this.house = house; } } Definition neuer Objekttypen Vorläufige Fassung Bei der Definition neuer Dienste können bestehende Dienste benutzt werden: setNameetc. von Person. thisbezeichnet in Java das ausführende Objekt. Wenn klar ist, dass es um einen Methodenaufruf anthishandelt, kann thisauch weggelassen werden. Andere OO Sprachen haben ähnliche spezielle Bezeichner, z.B.selfin Smalltalk. „this.house“ ist das Attribut des Objekts, nicht der Parameter.

Abstecher: Benennung neuer Methoden • Bedeutung und Korrektheit neuer Methoden • Java versteht Methodennamen nicht, sondern führt aus • Die folgende Methode ist korrekt, aber nicht erwartungskonform—und verwirrt damit Nutzer! publicvoidgetMyName() {System.err.println(myHouse); } • Diese Methode sollte eher „printHouseInfo()“ heißen • Folge: Intentionsfehler im Programm – Programm reagiert nicht wie erwartet. • Methoden immer gemäß ihrer Bedeutung benennen!

Konstruktoren und neue Objekttypen • Erben müsseneinen Konstruktor der Oberklasse aufrufen • Eine Unterklasse, die keinen Konstruktor definiert, hat implizit einen parameterlosen Konstruktor, der den parameterlosen Konstruktor der Oberklasse aufruft. public classMitarbeiter extends Person { // Implementierung ohne expliziten Konstruktor } public classMitarbeiter extendsPerson { Mitarbeiter() { super(); } // ... } Schlüsselwort für Zugriff auf Element des Vorfahren, hier: Konstruktor Das geht aber nur, wenn die Oberklasse einen parameterlosen Konstruktor definiert – sonst Compilefehler! (Passiert hier…)

Konstruktoren und neue Objekttypen public class Mitarbeiter extends Person { int officeNumber; // office number public Mitarbeiter(String name, String givenName, String address, String phone, int officeNr) { super(name,givenName,address,phone); setOfficeNumber(officeNr); } // more features... } // Beispiel: Instanziierung eines Mitarbeiters Mitarbeiter mueller = new Mitarbeiter("Mueller", "Tim", "Hauptstr. 10, 64289 Darmstadt", "06151-1234567", 10); • Person hat nur einen Konstruktor mit 4 Parametern • Achtung: Anders als Methoden werden Konstruktoren nicht vererbt! • Deswegen muss in Mitarbeiter ein expliziter Konstruktor implementiert werden, der den 4-parametrigen Konstruktor von Person aufruft.

Abstecher: Modellierungssprache • Modellierungssprache: eine grafische Notation (Sprache), in der wir Design-Modelle schreiben. • Abstrakter als Programmiersprachen. • Im Normalfall nicht ausführbar. • Teile des Codes können aber aus dem Modell generiert werden. Kleiner Abstraktions-sprung Mentales Modell Design Modell Kleine Repräsentations- lücke Compiler Maschinen-Level modulare Struktur des Programms

Abstecher: Unified Modeling Language (UML) • Sprache und Notation für die visuelle Entwurfsbeschreibungvon Modellen für Softwaresysteme • Festlegung, wie ein Softwaresystem konstruiert werden soll • Visualisierung, die auch für nicht-Informatiker leicht verständlich ist • Dokumentation von Software • Besonders wichtig, wenn ein großes System im Team entworfen wird • UML bietet eine Sammlung von Diagrammtypenan, um bestimmte Aspekte der Software zu beschreiben • Anwendungsfalldiagramm: Was kann welcher Akteur mit dem System machen? • Klassendiagramm: Beschreibt Beziehungen zwischen Klassen • Verhaltensdiagramme: Beschreiben, wie sich das System verhalten soll. • Implementierungsdiagramme: Beziehungen zwischen Komponenten • Wir betrachten im folgenden zunächst nur das Klassendiagramm

Das UML Klassendiagramm UML Notation für „Klasse“ Person • Klassendiagramm: • Klasseneigenschaften • Attribute • Methoden • Beziehungen: • Vererbung • (Teil-von) • (Abhängigkeiten) name: String … setName(String): void ... UML Notation für „erbt“ getOfficeNr(): int setOfficeNr(): void Mitarbeiter returnofficeNr; Vererbung ist eine transitive Relation:Manager erbt alles, wasMitarbeitererbt (z.B.setName(String)) UML Notation für Methoden-Implementierung getSupervisedList(): … Manager

Modellierung eines Grafiksystems • Im Folgenden verlassen wir die Immobilienverwaltung • Für OO-Modellierung zwar „praktisch “, aber nicht sehr interessant • Stattdessen wollen wir ein Grafiksystem modellieren • Bestehend aus einer Zeichenfläche und grafischen Objekten • Linie, Rechteck, Oval, Polygon, … • Wir kehren dafür zur PackageACM JTF zurück • Siehe Foliensatz T11, Stichwort „GraphicsProgram“ • Wir werden für die Modellierung ACM JTF nutzen • Nehmen uns aber Zeit, selbst eine gute Modellierung zu finden • Diese ist nicht unbedingt deckungsgleich mit ACM JTF • Es hat niemand behauptet, das Package sei perfekt…

Nutzung von ACM JTF Grafik • ACM JTF bietet mehr als Console, Dialog und Grafikausgabe • Ein (fast) komplettes Grafiksystem zum Zeichnen von Objekten • Objekte werden in der Reihe ihres Erscheinens gezeichnet: • Als Basis dient wieder das bewährte „GraphicsProgram“ • Wir nutzen aber zusätzliche Klassen für Grafikobjekte • Kreisbögen, Texte, Linien, Ovale, Rechtecke, Polygone

Grundkonzepte für Grafik mit ACM JTF • Für die Erstellung von Grafiken mit ACM JTF gilt: • Genutzt wird das gleiche Ausgabefenster wie in „HelloGraphics“ • Das Koordinatensystem beginnt oben links mit (0,0) • Die x-Achse wächst nach rechts, die y-Achse nach unten • Jede Koordinate entspricht einem Bildschirmpunkt (Pixel) • Als Koordinaten können int und double Werte genutzt werden • Grundkonzepte zur Erstellung von Grafiken • Die Klasse GCanvas ist die Zeichenfläche • Die Klasse GObject ist die Basisklasse für alle grafischen Objekte • Zum Zeichnen wird ein grafisches Objekt dem GCanvas hinzugefügt • Dazu dient die Methode add(GObject) der Klasse GCanvas • Diese Methode ist in jedem GraphicsProgram direkt nutzbar • Betrachten wir zunächst die grafischen Objekte…

Grafische Objekte: Klasse GObject • GObjectist die Basisklasse für alle Grafikobjekte • So wie Person die Basisklasse für Mitarbeiter, Kunde war (T12) • Besonders wichtige Methoden: • doublegetX(), doublegetY(), GPointgetLocation() • Liefert die X- bzw. Y-Koordinate des Objekts bzw. die Position als Punkt • voidsetLocation(double x, double y),voidsetLocation(GPoint p) • Setzt die Koordinate des Objekts als (x, y) oder über definierten Punkt • doublegetWidth(), doublegetHeight() • Liefert die Breite bzw. Höhe des Objekts • GDimensiongetSize() • Liefert die Größe des Objekts als GDimension-Objekt • GRectanglegetBoundingBox() • Liefert das kleinste Rechteck, das das Objekt vollständig umfasst

Grafische Objekte: Klasse GObject • Verschieben eines Objekts: • voidmove(doubledx, doubledy),voidsetLocation(GPoint p) • Verschiebt das Objekt um (dx, dy) bzw. setzt es an Punkt p • Ruft intern setLocation(getX() + dx, getY() + dy) auf • voidmovePolar(double r, doubletheta) • Verschiebt das Objekt um r Einheiten Richtung theta (Winkelgrad) • Farbe des Objekts auslesen oder setzen: • voidsetColor(Color c), Color getColor() • Siehe die Java-Dokumentation von java.awt.Color • Meist langen die folgenden vordefinierten konstanten Farbwerte: • Color.BLACK, Color.RED, Color.BLUE, Color.DARK_GRAY, Color.YELLOW, Color.MAGENTA, Color.GRAY, Color.GREEN, Color.ORANGE, Color.LIGHT_GRAY, Color.CYAN, Color.PINK, Color.WHITE • Am Anfang der Klasse muss „importjava.awt.Color;“ stehen

Grafische Objekte: Klasse GObject • Beeinflussung der Zeichenreihenfolge • Normalerweise werden „neue“ Objekte vorne gezeichnet • Um das anzupassen, gibt es vier Methoden: • voidsendToFront(), voidsendToBack() • Ordnet das Objekt ganz vorne bzw. ganz hinten an • voidsendForward(), void sendBackward() • Bringt das Objekt eine Ebene nach vorne bzw. nach hinten • Testen, ob ein Punkt im Objekt enthalten ist • booleancontains(double x, double y)booleancontains(GPoint p) • Liefert true, wenn der Punkt im Objekt liegt, sonst false

Anzeigefläche: GCanvas • GraphicsProgram umfasst schon einen GCanvas • Wesentliche Methoden in beiden Klassen: • voidadd(GObjectgo) • Fügt das Objekt go zum GCanvas hinzu an der Position von go • voidadd(GObjectgo, double x, double y)voidadd(GObjectgo, GPoint p) • Fügt das Objekt go zum GCanvas an angegebener Position hinzu • voidremove(GObjectgo) • Entfernt das grafische Objekt go vom GCanvas • voidremoveAll() • Entfernt alle grafischen Objekte vom GCanvas • intgetWidth(), intgetHeight() • Liefert die Breite bzw. Höhe des GCanvas

Anzeigefläche: GCanvas • voidsetBackground(Color bgColor) • Setzt die Hintergrundfarbe auf bgColor • GObjectgetElementAt(double x, double y)GObjectgetElementAt(GPoint p) • Liefert das oberste Element, zu dem Punkt (x, y) bzw. p gehört • Ruft contains(x, y) bzw. contains(p) auf allen Objekten auf • Beispiel (T11, Folie 20): // AnlegeeinesObjekts: GLabelfuerTexte GLabel label = new GLabel("hello, world"); // neuer Text // Schriftartzuweisen label.setFont("SansSerif-100"); // Font: ohne Serifen // Position berechnen und zum GCanvashinzufuegen double x = (getWidth() - label.getWidth()) / 2; // mittig double y = (getHeight() + label.getAscent()) / 2; // mittig add(label, x, y); // Text hinzufuegen zum GCanvas

Beispiel: zwei Objekte auf der Zeichenfläche importjava.awt.Color; // fuer Farben importacm.graphics.GOval; // fuer das Oval importacm.graphics.GRect; // fuer das Rechteck importacm.program.GraphicsProgram; // Hauptklasse public class FeltBoardextendsGraphicsProgram { publicvoidrun() {/** Runs theprogram */ GRectrect = newGRect(100, 50, 100, 100 / PHI); // Rechteck def. rect.setFilled(true); // ist gefuellt... rect.setColor(Color.RED); // ...mit Farbe rot add(rect); // zum GCanvas hinzu GOval oval = newGOval(150, 50 + 50 / PHI, 100, 100 / PHI); oval.setFilled(true); // ebenfalls gefuellt... oval.setColor(Color.GREEN); // aber gruen add(oval); // zum GCanvas hinzu }

Beispiel: zwei Objekte auf der Zeichenfläche /** Constant representing the golden ratio */ public static final doublePHI = 1.618; /* Standard Java entrypoint */ /* This method can be eliminated in most Java environments */ public static void main(String[] args) { newFeltBoard().start(args); } } Ausgabe (siehe Folie 27): Da das Rechteck „älter“ ist,liegt es hinter dem spätereingefügten Oval.

Vorhandene Unterklassen von GObject • GLine: Linie aus zwei Punkten • GLine(double x1, double y1, double x2, double y2) • Legt die Linie von (x1, y1) nach (x2, y2) an • GPointgetStartPoint()GPointgetEndPoint() • Liefert den Start- bzw. Endpunkt der Linie • GOval: ovale Form • GOval(double x, double y, double w, double h) • Oval mit linker oberer Ecke (x, y) und Radien w bzw. h • GLabel: Text • GLabel(String text, double x, double y) • Text „text“ beginnend an Punkt (x, y) mit Basislinie y

Vorhandene Unterklassen von GObject • GArc: Kreisbogen; wie Oval, aber mit Start-/Endwinkel • GArc(double x, double y, double w, double h, doublestart, double sweep) • Bogen mit linker oberer Ecke der Bounding Box an (x, y), Radien w bzw. h, Startwinkel start und Umfang sweep in Grad • Weitere Methoden zum Abfragen oder Setzen der Winkel • GPolygon: Polygon mit beliebig vielen Knoten • GPolygon(double x, double y) • Legt Polygon an Startposition ohne Knoten an • GPolygon(GPoint[] points) • Legt Polygon mit Startknoten aus dem Array an • addEdge(double x, double y) • Fügt Kante vom letzten Knoten zu (x, y) hinzu • voidmarkAsComplete() • Polygon als „fertig“ markieren; kein Hinzufügen mehr möglich

Vorhandene Unterklassen von GObject • GRect: Rechteck in drei Varianten • GRect(double x, double y, double w, double h) • Legt Rechteck mit Knoten (x,y) und (x+w, y+h) an • G3DRect(double x, double y, double w, double h) • Legt Rechteck mit „3D-Effekt“ an • Zusatzparameter: booleanraised; wenn true, „erhöht“ gezeichnet • GRoundRect(double x, double y, double w, double h) • Rechteck mit abgerundeten Ecken • Zusatzparameter: • double arcSize– Größe des Bogens der Kanten • double arcWidth, double arcHeight– Individuelle Bogengröße • GImage: Einbinden von Bildern • GImage(Image image, double x, double y) • Legt ein Bild an; vorerst nicht weiter betrachtet

Exkurs: Zeichnen von GObject-Instanzen • Das Zeichnen von GObject-Instanzen erfolgt intern • Methode voidpaint(Graphics g), definiert in Klasse GObject • Graphics ist eine umfangreiche Klasse aus java.awt • Bitte konsultieren Sie die Java API Dokumentation für Details! • Zeichnen des Rechtecks (leicht vereinfacht) mit Graphics: publicvoidpaint(Graphics g) { // Zeichne Rechteck ab (x, y) mit Breite u. Hoehe g.drawRect(getX(), getY(), getWidth(),getHeight()); } • Zeichnen eines Quadrats (leicht vereinfacht) mit Graphics: publicvoidpaint(Graphics g) { // Zeichne Quadrat ab (x, y) mit passender Groesse g.drawRect(getX(), getY(), size, size); }

Finden der „passenden“ Vererbungshierarchie • Die Bestimmung der „passenden“ Modellierung ist nicht immer offensichtlich • Als Beispiel betrachten wir die folgenden Klassen als Teil eines Zeichensystems: • Punkt (GPoint) • Rechteck (GRect) • Gegebenfalls zusätzlich noch die Klasse Quadrat (GSquare) • Wir betrachten nun verschiedene Modellierungen • Dabei begründen wir, warum die Modellierung (nicht) „gut“ ist

Modellierung I: Punkt als Basisklasse GPoint • Überlegung: „jedes grafische Objekt besteht aus mindestens einem Punkt“ • Regel 1 der Vererbung: der Erbe ist eine Spezialisierung • Ist ein „Rechteck ein spezieller Punkt“? • Was wir eigentlich meinten, war: ein Rechteck hat (mindestens) einen Punkt • Nutze einen GPointals Attribut, nicht als Oberklasse • Siehe Regel 2 der Vererbung: „ist-ein“ vs. „hat-ein“ Keine gute Modellierung GRect

Modellierung II: Punkt neben Rechteck • Punkt sollte nicht die Basisklasse von Rechteck sein • Andere grafische Objekte scheiden ebenso aus wie Punkt • Wir definieren eine allgemeine Basisklasse „GObject“ • Diese repräsentiert kein konkretes Objekt • Konkrete Methoden wie paint lassen wir in GObject leer • Sammelt gemeinsame Funktionalität aller grafischen Objekte • Die konkreten Aufgaben, etwa das Zeichnen, leisten die Erben GObject GRect GPoint

Modellierung III: Rechteck und Quadrat • Wie modellieren wir Rechteck und Quadrat? • Ein Quadrat ist spezieller als ein Rechteck • Daher könnten wir Quadrat als Erbe von Rechteck deklarieren GObject Ist das eine gute Modellierung? GSquare GRect GPoint

Modellierung III: Rechteck als Basis für Quadrat • Achtung: Regel 3 und 5 der Vererbung • 3: „Neue Klasse erbt alle Methoden und Attribute der Basisklasse“ • 5: „Verhalten überschriebener Methode muss zu Vorfahr passen“ • Quadrat erbt also alle Attribute und Methoden von Rechteck • Damit auch die beiden Punkte oben links, unten rechts • Sowie Methoden wie setWidth(double), setHeight(double) • Wie stellen wir sicher, dass die Form quadratisch ist? • Wie ändern wir die Methode zur Änderung der Größe? • Rechteck: zwei Zahlen oder ein Dimension-Objekt • Quadrat: eine Zahl • Die geerbte Methode von Rechteck muss es weiterhin geben • Wir können Sie höchstens „umschreiben“: publicvoidsetSize(double w, double h) { setSize((w + h) / 2); } • Entspricht nicht der Vorstellung des Benutzers  Regel 5

Modellierung IV: Rechteck erbt von Quadrat • Wie ist es umgekehrt: Rechteck erbt von Quadrat? • Rechteck übernimmt Größe und „fügt zweite Größenangabe hinzu“ voidsetSize(doublesize) { setSize(size, size); } • Prinzipiell ist das möglich und verstößt nicht gegen Regel 3 und 5 • Aber: ein Rechteck ist eine Verallgemeinerung von Quadrat, eben keine Spezialisierung! • Diese Vererbung ist also auch nicht geeignet • Daher ordnen wir GSquare parallel zu GPoint, GRect ein

Verwendung neuer Objekttypen • Wir erweitern unsere Klasse FeltBoard (Folie 34-35): // Code bis Ende Methode "run" wie bisher add(oval); // zum GCanvas hinzu // neu: es kommt ein GSquare hinzu GSquaresquare = newGSquare(120, 80, 60); square.setColor(Color.BLACK); add(square); // Rest wie gehabt...

Funktionsvorlagen & Abstrakte Klassen • Betrachten wir die Klasse GObject einmal genauer • Die Klassen GPoint, GRect und GSquare erben von GObject • Dazu zählt auch die Methode voidpaint(Graphics g) • Wie implementiert man diese Methode für ein allgemeines GObject? • Wir wissen hier gar nicht, was für eine Art von Objekt dies sein soll! • Für solche Fällen können Klassen Operationen deklarieren, die in der Klasse nicht implementiert werden. • Solche Operationen werden abstrakte Methoden genannt. • Klassen, die mindestens eine abstrakte Methode deklarieren, werden abstrakte Klassen genannt. • Im Folgenden werden wir zeigen, wie abstrakte Klassen Wiederverwendungunterstützen, wenn ähnliche, aber nicht identische Aufgaben implementiert werden.

Abstrakte Klassen: GObject • GObject repräsentiert beliebige grafische Objekte • Also nichts konkretes wie einen Kreis, Quadrat, nur eine Vorlage • GObject liefert allgemeine Funktionalität für alle Erben • Setzen und Abfragen der Koordinate und Farbe • Abfragen der Grenzen (bounds) • Zeichnen des Objekts mittels paint(Graphics) • Nicht alle Methoden können implementiert werden • Wie kann man eine „Vorlage“ zeichnen? Als Kreis, Quadrat, …? • Wie kann man für eine Vorlage die Grenzen angeben? • Wie geht man mit dieser Situation um? • Was wollen wir? • Jeder konkrete Erbe muss die beiden Methoden implementieren • Die Überprüfung muss durch Java forciert werden, nicht nur durch (eventuell ignorierte) Kommentare im Quelltext

Grundlagen der Informatik 1

Grundlagen der Informatik 1

Presentation Transcript

Grundlagen der Informatik

INFORMATIK: GRUNDLAGEN, KAP 1 - 2

Informatik Grundlagen

Grundlagen der Informatik

Grundlagen der Informatik I Thema 0: Einführung

Grundlagen der Informatik I Thema 16: Ausnahmebehandlung

Grundlagen der Informatik 1 Thema 1: Grundelemente der Programmierung

Grundlagen der Informatik 1 Thema 8: Akkumulation von Wissen

Grundlagen der Informatik

Grundlagen der Informatik

Grundlagen der Informatik

Grundlagen der Informatik Wintersemester 2009

Grundlagen der Informatik 1 Thema 6: Generative Rekursion

Grundlagen der Informatik 1

Grundlagen der Informatik

Grundlagen der Informatik Wintersemester 2007

Technische Grundlagen der Informatik 1

Grundlagen der Informatik

Grundlagen der Informatik 1 Thema 7: Komplexität von Algorithmen

Grundlagen der Elektrotechnik I für Informatik

Grundlagen der Informatik

Grundlagen der Informatik 1 Thema 10: Zuweisungen und andere Effekte