13 Vererbung

In diesem Kapitel müssen wir mal auf Grafik verzichten und einen weiteren Blick auf Klassen und Objekte werfen. Dazu entwerfen wir eine kleine Software, die Musiktitel und Filme verwalten kann.

13.1 MyTunes: Eine Musik- und Filmverwaltung

Unsere Software soll unsere Bibliothek an Musik- und Filmdateien verwalten. Das heißt konkret: wir können Titel suchen, abspielen und vielleicht auch Playlists anlegen.

Erster Ansatz

Da wir objektorientiert arbeiten, entwerfen wir je eine Klasse für (1) Songs und (2) Filme. Ein konkreter Song wird dann durch eine Instanz (Objekt) repräsentiert. Zu jedem Song wollen wir Titel, Künstler und Dateinamen auf der Festplatte speichern. Bei Filmen speichern wir Titel, Regisseur und Dateinamen.

Unsere Klasse Song sieht wie folgt aus:

class Song {
  String title;
  String artist;
  String file;

  // Konstruktor
  Song(String aTitle, String aArtist, String aFile) {
    title = aTitle;
    artist = aArtist;
    file = aFile;
  }
}

Für Filme schreiben wir eine Klasse Movie:

class Movie {
  String title;
  String director;
  String file;

  // Konstruktor
  Movie(String aTitle, String aDirector, String aFile) {
    title = aTitle;
    director = aDirector;
    file = aFile;
  }
}

Um unsere Klassen zu testen, müssen wir Testobjekte erzeugen, die wir in Listen speichern.

void setup() {

  // Liste mit Test-Filmen
  ArrayList<Movie> movies = new ArrayList<Movie>();
  movies.add(new Movie("Alien", "Ridley Scott", "alien.mov"));
  movies.add(new Movie("Der Pate", "Francis Ford Coppola", "pate.mov"));
  movies.add(new Movie("Gravity", "Alfonso Cuarón", "gravity.avi"));

  // Ausgeben
  for (Movie m: movies) {
    println(m);
  }

  // Liste mit Test-Songs
  ArrayList<Song> songs = new ArrayList<Song>();
  songs.add(new Song("OMG!", "Marteria", "omg.wav"));
  songs.add(new Song("Happy", "Pharrell Williams", "happy.wav"));

  // Ausgeben
  for (Song s: songs) {
    println(s);
  }
}

MyTunes$Movie@3fa3e565
MyTunes$Movie@7aa16cf5
MyTunes$Movie@13e36e92
MyTunes$Song@6b398cec
MyTunes$Song@1a8e93ba

So sieht es aus, wenn Java/Processing Objekte ausgibt.

Objektausgabe mit toString()

Die Ausgabe ist leider nicht sehr aussagekräftig. Deshalb bedienen wir uns einer Technik, um die Ausgabe von Objekten schöner zu machen: wenn Sie in einer Klasse die Methode toString() hinzufügen, dann wird diese Methode aufgerufen, sobald das Objekt mit print() ausgegeben wird.

class Movie {
  ...

  // Rückgabetyp muss String sein!
  String toString() {
    return "MOVIE \"" + title + "\" von " + director +
    ", zu finden unter: " + file;
  }
}

class Song {
  ...

  // Rückgabetyp muss String sein!
  String toString() {
    return "SONG \"" + title + "\" von " + artist +
    ", zu finden unter: " + file;
  }
}

Falls Sie sich über das "MOVIE \"" wundern, das wird gleich erklärt. Die Ausgabe ist jetzt schöner:

MOVIE "Alien" von Ridley Scott, zu finden unter: alien.mov
MOVIE "Der Pate" von Francis Ford Coppola, zu finden unter: pate.mov
MOVIE "Gravity" von Alfonso Cuarón, zu finden unter: gravity.avi
SONG "OMG!" von Marteria, zu finden unter: omg.wav
SONG "Happy" von Pharrell Williams, zu finden unter: happy.mp3

Escape-Sequenzen in Strings

Wenn Sie in einem String Anführungszeichen einbauen wollen, dann haben Sie ein Problem: Wie verhindern Sie, dass Processing denkt, dass an dieser Stelle der String zu Ende ist:

String foo = "dies ist ein Anführungszeichen: ""; // Fehler

Sie müssen das vorletzte Anführungszeichen kennzeichnen, so dass Processing weiß, dass es im String ist und nicht die Begrenzung darstellt. Dieses Kennzeichnen funktioniert mit einem vorangestelltem Backslash:

String foo = "dies ist ein Anführungszeichen: \""; // OK

Analog funktioniert das für "unsichtbare" Zeichen wie Tab (\t), Zeilenumbruch (\n) und den Backslash selbst (\\).

Probleme und Code-Duplizierung

Unser Programm hat einige unschöne Aspekte:

• Die Klassen Movie und Song sehen fast gleich aus. Das bedeutet, dass Code doppelt vorhanden ist. Man nennt das Code-Duplizierung. Das gilt als schlechte Programmierpraxis, weil ich bei Änderungen in einem Code (z.B. einen Fehler beheben oder den Code schneller/eleganter gestalten) auch den anderen ändern müsste.
• Wir müssen die Medien in zwei Listen verwalten, besser wäre alles in einer Datenstruktur.

Ein wichtiges Designprinzip vom Erstellen von Klassen ist also die Vermeidung von Code-Duplizierung, im Englischen spricht man auch von DRY: Don't Repeat Yourself. Im nächsten Kapitel lernen wir eine Möglichkeit kennen, Code-Duplizierung zu vermeiden.

13.2 Klassenhierarchie und Vererbung

In objektorientierten Sprachen kann man zwei Klassen A und B zueinander in Beziehung setzen, so dass A die Oberklasse von B ist. Die Konsequenz lehnt sich an die Eltern-Kind-Beziehung beim Menschen an: Die Unterklasse "erbt" alle Instanzvariablen und Methoden der Oberklasse. Das bedeutet technisch, dass die Unterklasse zunächst mal alle Instanzvariablen und Methoden der Oberklasse benutzen kann, als wären sie in der eigenen Klasse definiert worden.

Man kann sich das anhand verschiedener Typologien verdeutlichen. Zum Beispiel: ein Auto (Klasse) ist ein Fahrzeug (Klasse). Auto erbt von Fahrzeug die Eigenschaft, dass es sich fortbewegen kann. Ein Auto hat aber auch Eigenschaften, die die Oberklasse (Fahrzeug) nicht hat, z.B. dass es vier Räder hat. Ein Fahrrad (Klasse) könnte eine weitere Unterklasse von Fahrzeug sein und hat die Eigenschaft, zwei Räder zu besitzen. Das ganze kann man in einem Klassendiagramm festhalten.

Die Pfeile bedeuten "ist Unterklasse von" und müssen genau so gezeichnet werden (d.h. offene Spitze, durchgezogener Strich), denn diese Diagramme sind standardisiert.

Ist-ein

Eine Klassenhierarchie zu erstellen ist ein Designproblem, d.h. es gibt nicht immer ein richtig oder falsch. Eine gute Daumenregel, um herauszufinden, ob die Klassenbeziehungen stimmen ist die "ist-ein"-Regel. Man sollte immer sagen können "<Unterklasse> ist ein <Oberklasse>". Im obigen Beispiel also "Auto ist ein Fahrzeug" und "Fahrrad ist ein Fahrzeug".

Einfaches Beispiel

Definieren wir mal eine einfache Klasse A mit einer Eigenschaft und einer Methode.

class A {
  int anum = 10;

  void afun() {
    println("a " + anum);
  }
}

Um Processing zu sagen, dass Klasse B die Unterklasse von A ist, benutzen wir das Schlüsselwort "extends" (engl. erweitert):

class B extends A {
  int bnum = -99;

  void bfun() {
    println("b " + anum + " " + bnum);
  }
}

Sie sehen hier, dass die Klasse B auf die Instanzvariable anum zugreifen kann, obwohl diese Variable doch eigentlich zu A gehört! Der Grund ist, dass B diese Variable geerbt hat, d.h. in B gibt es genauso eine Variable anum.

void setup() {
  A a = new A();
  B b = new B();
  a.afun();
  b.bfun();
  b.afun();
}

Beachten Sie, dass man auf b auch die Methoden der Oberklasse aufrufen kann, in diesem Fall afun . Auch die Methoden vererbt A an B.

a 10
b 10 -99
a 10

Typen und Subtypen

Sobald Sie eine Klasse A schreiben, erzeugen Sie auch einen neuen Datentypen A, denn Sie können natürlich dann Variablen herstellen, die Instanzen von A speichern sollen.

Wenn Klasse B Unterklasse von A ist, dann ist der Datentyp B automatisch Subtyp von A. Das bedeutet, dass eine Variable von Typ A auch Objekte von Typ B speichern kann.

Beispiel 1:

A a = new A();
B b = new B();
A a2 = b; // korrekt!

Beispiel 2: Nehmen wir an, es gäbe die Klassen Fahrzeug, Auto und Fahrrad, wie oben skizziert.

Fahrzeug f;
Auto a = new Auto();
f = a; // korrekt

Fahrzeug f2 = new Fahrrad(); // ebenso!

Das ist korrekt, denn: ein Auto ist ein Fahrzeug und ein Fahrrad ist ein Fahrzeug. Umgekehrt geht es nicht:

Auto a;
a = new Fahrzeug(); // falsch!

denn ein Fahrzeug ist nicht (immer) ein Auto.

MyTunes 2: Vererbung nutzen

Mit unserem neuen Wissen verbessern wir unsere Datenbank. Da die Instanzvariablen vererbt werden, können wir die gemeinsamen Variablen in eine neue Oberklasse "Medium" auslagern:

Die Klasse Medium hat einen eigenen Konstruktor.

class Medium {
  String title;
  String file;

  Medium(String aTitle, String aFile) {
    title = aTitle;
    file = aFile;
  }
}

Verwendung von super()

Um Code-Duplizierung zu vermeiden, können Sie im Konstruktor einer Klasse den Konstruktor der Oberklasse aufrufen. In unserem Beispiel werden die Variablen title und file im Konstruktor von Medium initialisiert. Wir wollen diesen Code nicht im Konstruktor von Movie duplizieren.

Also rufen wir im Konstruktor von Movie den Konstruktor der Oberklasse mit super() auf. super() hat immer die gleiche Anzahl von Parametern wie der Konstruktor (bzw. einer der Konstruktoren) der Oberklasse. In diesem Fall sind das zwei Parameter:

class Movie extends Medium {
  String director;

  Movie(String aTitle, String aDirector, String aFile) {
  super(aTitle, aFile);
  director = aDirector;
  }

  String toString() {
    return "MOVIE \"" + title + "\" von " + director +
    ", zu finden unter: " + file;
  }
}

Wichtig: super() muss immer die erste Anweisung im Konstruktor sein. Es gibt übrigens noch eine weitere Verwendung von super, um Methoden der Oberklasse aufzurufen. Letzteres wird aber ohne Klammern geschrieben und behandeln wir später. Nicht verwechseln!

Analog für die Klasse Song:

class Song extends Medium {
  String artist;

  Song(String aTitle, String aArtist, String aFile) {
    super(aTitle, aFile);
    artist = aArtist;
  }

  String toString() {
    return "SONG \"" + title + "\" von " + artist +
    ", zu finden unter: " + file;
  }
}

Wir passen den Teil an, wo wir die Listen erzeugen:

Jetzt können wir alle Objekte in einer Liste vom Typ Medium ablegen, da Movie und Song Subtypen von Medium sind. Die Verwaltung wird so wesentlich übersichtlicher:

void setup() {

  // Nur noch eine Liste für beide Medientypen
  ArrayList<Medium> media = new ArrayList<Medium>();

  media.add(new Movie("Alien", "Ridley Scott", "alien.mov"));
  media.add(new Movie("Der Pate", "Francis Ford Coppola", "pate.mov"));
  media.add(new Movie("Gravity", "Alfonso Cuarón", "gravity.avi"));
  media.add(new Song("OMG!", "Marteria", "omg.wav"));
  media.add(new Song("Happy", "Pharrell Williams", "happy.wav"));

  // Nur noch eine For-Schleife zur Ausgabe
  for (Medium m: media) {
    println(m);
  }
}

Einschub: Der ternäre Operator statt If-Else

Es gibt Fälle, wo das If-Else etwas sperrig ist. Nehmen wir an, Ihr Programm soll ausgeben, ob jemand jung (< 40 Jahre) oder alt (>= 40 Jahre) ist:

String altersklasse(int alter) {
  if (alter < 40) {
    return "jung";
  } else {
    return "alt";
  }
}

Der sogenannte ternäre Operator erlaubt es Ihnen, diese drei Bestandteile (Bedingung, Fall 1, Fall 2) sehr kompakt in folgender Form zu schreiben:

BEDINGUNG ? FALL1 : FALL2

In unserem Beispiel wäre dies:

String altersklasse(int alter) {
  return alter < 40 ? "jung" : "alt";
}

Der ternäre Operator wird auch häufig verwendet, um Strings zusammenzusetzen. Dann müssen Sie den ganzen Ausdruck einklammern:

int alter = 50;
println("Sie sind " + (alter < 40 ? "jung" : "alt"));

Lisa Müller, Studentin, Matrikelnr. 809221
Professor Dr. Rainer Unsinn
Augustin Burg, Student, Matrikelnr. 007007
Professorin Hilde Brün

class A {
  ...
}

class B extends A {
  ...
}

Animal x = new Hase(); // korrekt

13.3 Vererbung allgemein

Im obigen Beispiel haben wir eine einfache Klassenhierarchie gesehen. Schauen wir uns eine etwas komplexere an:

In diesem Klassendiagramm sehen Sie für jede Klasse die Instanzvariablen und die Methoden in eigenen Bereichen. Etwas ungewohnt ist die Angabe der Datentypen nach dem Format

<Variablenname> : <Typ>

Das hängt damit zusammen, dass Klassendiagramme auch für andere Programmiersprachen als Java/Processing verwendet werden und jede Programmiersprache eine andere Schreibweise hat.

Oberklassen und direkte Oberklassen

Sie wissen, dass eine Unterklasse C alle Instanzvariablen und Methoden von Ihrer Oberklasse B erbt. Wenn Klasse B wiederum eine Oberklasse A hat, dann erbt C diese Dinge auch von A! Im Beispiel oben erbt Klasse Auto auch die Instanzvariablen und Methoden der Klasse Produkt.

Dies liegt daran, dass Produkt auch eine Oberklasse von Auto ist. Allgemein kann man sagen:

WENN: A ist Oberklasse von B UND B ist Oberklasse von C
DANN GILT: A ist Oberklasse von C

(Diese Eigenschaft nennt man Transitivität.)

Dann gilt allgemein: Eine Klasse erbt die Instanzvariablen und Methoden von all ihren Oberklassen. Im Beispiel oben nennt man übrigens die Klasse Fahrzeug die direkte Oberklasse von Auto, um anzuzeigen, dass keine andere Klasse zwischen den beiden ist.

Jede Klasse hat nur eine direkte Oberklasse

Eine wichtige Regel in Java ist, dass jede Klasse maximal eine direkte Oberklasse haben darf. Das heißt, das hier ist nicht erlaubt (obwohl es im echten Leben durchaus Sinn macht):

Warum nicht? Man könnte doch einfach die Eigenschaften und Methoden von beiden Oberklassen erben. Probleme gibt es aber, wenn die zwei Oberklassen Variablen haben, die genau gleich heißen, oder Methoden haben, die die gleiche Signatur haben. Welche Variable soll Java wählen? In Java hat man dies also verboten, aber in anderen Sprachen wie C++ oder LISP ist es durchaus erlaubt, erfordert aber Zusatzmechanismen (siehe Wikipedia Mehrfachvererbung).

Konstruktoren: Wichtige Regeln

Sie wissen, dass man pro Klasse mehrere Konstruktoren definieren kann. Sie wissen, dass man mit super() einen Konstruktor der Oberklasse aufrufen kann.

Hier noch der Vollständigkeit halber ein paar Regeln.

Regel 1: Wenn in einer Klasse kein Konstruktor definiert ist, wird automatisch ein leerer Konstruktor ohne Parameter definiert.

Sie können also folgendes definieren:

class Foo {

  // eine Testmethode
  void hello() {
    println("servus");
  }

}

Beim Erzeugen einer neuen Instanz wird der Konstruktor ohne Parameter aufgerufen - er wird von Processing hinzugefügt:

void setup() {
  Foo foo = new Foo();
  foo.hello();
}

servus

Regel 2: Sobald mindestens ein eigener Konstruktor definiert wird, wird der Konstruktor ohne Parameter nicht automatisch generiert.

Erweitern Sie die obige Klasse um einen Konstruktor (der Parameter x hat keine Funktion)...

class Foo {

  Foo(int x) {
  }

  void hello() {
    println("servus");
  }

}

... dann können Sie das Programm nicht mehr ausführen. Sie erhalten die Fehlermeldung:

The constructor ...Foo() is undefined

Regel 3: Hat Ihre Klasse eine Oberklasse, dann wird in allen Konstruktoren automatisch super() aufgerufen, sobald eine Instanz erzeugt wird - sofern nicht ein eigenes super() vom Programmierer eingefügt wurde.

class Bar {

  Bar() {
    println("Konstruktor von Bar");
  }

}

class Foo extends Bar {

  Foo() {
    // Processing führt hier super() aus
    println("Konstruktor von Foo");
  }

}

Wenn Sie eine Instanz von Foo erzeugen...

void setup() {
  Foo foo = new Foo();
}

...sehen Sie, dass zuerst der Konstruktor der Oberklasse aufgerufen wird. Erst dann wird der Code des Konstruktors von Foo ausgeführt:

Konstruktor von Bar
Konstruktor von Foo

Ein subtiler Fehler tritt auf, wenn Sie in der Oberklasse einen eigenen Konstruktor mit Parameter/n definieren. Es wird kein Konstruktor ohne Parameter automatisch definiert (Regel 2).

class Bar {

  // Konstruktor hat jetzt Parameter
  Bar(int x) {
    println("Konstruktor von Bar");
  }

}

class Foo extends Bar {

  Foo() {
    println("Konstruktor von Foo");
  }

}

Wenn Sie wieder eine Instanz von Foo anlegen wollen, versucht Processing den Konstruktor ohne Parameter von Bar aufzurufen, der ja nicht existiert. Dies endet mit einem Fehler:

Implicit super constructor ...Bar() is undefined.

Um den Fehler zu beheben, gibt es drei Möglichkeiten: (a) Sie fügen einen leeren Konstruktor zu Bar hinzu, (b) Sie löschen den eigenen Konstruktor, so dass der parameterlose Konstruktor automatisch erzeugt wird oder (c) Sie rufen selbst super() auf, allerdings mit Parameter.

class Bar {

  Bar(int x) {
    println("Konstruktor von Bar");
  }

}

class Foo extends Bar {

  Foo() {
    super(5);
    println("Konstruktor von Foo");
  }

}

13.4 Beispiel Animation

Schauen wir uns ein weiteres Beispiel aus dem Bereich Animation an.

Animatierte Objekte

Wir haben den typischen, sich bewegenden und abprallenden Ball als Klasse:

class Ball {
  PVector location;
  PVector speed;

  // Konstruktor mit zufälligen Anfangswerten
  // für Startpunkt und Geschwindigkeit
  Ball() {
    location =
    new PVector(random(0, width), random(0, height));
    speed =
    new PVector(random(-3, 3), random(-3, 3));
  }

  // Zeichnen
  void render() {
    ellipse(location.x, location.y, 20, 20);
  }

  // Koordinaten anpassen und das Abprallen regeln
  void update() {
    location.add(speed);
    if (location.x > width || location.x < 0) {
      speed.x = -speed.x;
    }

    if (location.y > height || location.y < 0) {
      speed.y = -speed.y;
    }
  }
}

Das Hauptprogramm könnte so aussehen (wichtig ist, dass der Konstruktor in setup aufgerufen wird und nicht im Variablenteil darüber, weil dort height und width noch nicht gesetzt sind).

Ball b;

void setup() {
  size(200, 200);
  b = new Ball();
}

void draw() {
  background(0);
  fill(255);
  noStroke();

  b.update();
  b.render();
}

Jetzt stellen Sie sich vor, Sie möchten ein weiteres Objekt fliegen lassen, ein Quadrat. Im Grunde wäre der Code fast identisch.

Einziger Unterschied: die Methode render() funktioniert bei Quad anders, da die natürlich ein Quadrat zeichnet...

class Quad {
  PVector location;
  PVector speed;

  Quad() {
    location =
    new PVector(random(0, width), random(0, height));
    speed =
    new PVector(random(-3, 3), random(-3, 3));
  }

  void render() {
    rectMode(CENTER);
    rect(location.x, location.y, 20, 20);
  }

  void update() {
    location.add(speed);
    if (location.x > width || location.x < 0) {
      speed.x = -speed.x;
    }

    if (location.y > height || location.y < 0) {
      speed.y = -speed.y;
    }
  }
}

Wieder hilft uns die Klassenhierachie. Wir führen eine neue Klasse ein, die alle gemeinsamen Elemente enthält:

• Standort (location)
• Geschwindigkeitsvektor (speed)
• update-Methode

Wir nennen die neue Oberklasse Mover:

Im Code verschieben wir alle Funktionalität in Mover, bis auf die Methode render natürlich:

class Mover {
  PVector location;
  PVector speed;

  Mover() {
    location =
    new PVector(random(0, width), random(0, height));
    speed =
    new PVector(random(-3, 3), random(-3, 3));
  }

  void update() {
    location.add(speed);
    if (location.x > width || location.x < 0) {
      speed.x = -speed.x;
    }

    if (location.y > height || location.y < 0) {
      speed.y = -speed.y;
    }
  }
}

Die Klassen Ball und Quad sind Unterklassen von Mover und enthalten wesentlich weniger Code:

class Ball extends Mover {
  void render() {
    ellipse(location.x, location.y, 20, 20);
  }
}

class Quad extends Mover {
  void render() {
    rectMode(CENTER);
    rect(location.x, location.y, 20, 20);
  }
}

Mit folgendem Hauptprogramm können Sie den Code testen:

void setup() {
  size(200, 200);
  b = new Ball();
  q = new Quad();
}

void draw() {
  background(0);
  fill(255);
  noStroke();

  b.update();
  q.update();
  b.render();
  q.render();
}

Die obige Klasse Mover könnte in einem Computerspiel eine Menge verschiedener Unterklassen haben: Hinternisse, Bösewichter, Lebensrationen und Waffen... Doch wir haben ein Problem: wie verwalten wir all diese Objekte effizient? Für jeden Bestandteil des Spiels eine eigene Variable anzulegen, wäre kaum machbar. Wir hätten viel lieber eine Liste:

ArrayList<Mover> things = new ArrayList<Mover>();

Dann könnten wir in draw() einfach alle Objekte mit einer For-Schleife updaten und zeichnen:

for (Mover m: things) {
  m.update();
  m.render(); // Fehler: Mover hat kein render
}

Zurzeit geht das nicht, weil die Klasse Mover keine Methode render hat. Muss auch so sein, denn die Klasse Mover hat ja keine bestimmte Form, die sie zeichnen kann. Wir können dieses Problem erst im nächsten Kapitel mit Hilfe von abstrakten Klassen und abstrakten Methoden lösen.