Polymorphie und Überladung

„Amigo, magst du Wale?“

„Wale? Nö, noch nie davon gehört.“

„Ein Wal ist wie eine Kuh, nur größer und er kann schwimmen. Übrigens stammen Wale zufälligerweise von den Kühen ab. Äh, oder zumindest haben sie einen gemeinsamen Vorfahren. Ganz egal.“

„Hör mal zu. Ich möchte dir ein weiteres wirklich mächtiges Werkzeug der OOP vorstellen: Polymorphie. Sie hat vier Merkmale.“

1) Methoden überschreiben.

Stell dir vor, du hast eine „Kuh“-Klasse für ein Spiel geschrieben. Sie hat eine Menge Member-Variablen und Methoden. Objekte dieser Klasse können verschiedene Dinge tun: laufen, essen, schlafen. Kühe klingeln beim Laufen außerdem mit einer Glocke. Nehmen wir an, du hast alles in der Klasse bis ins kleinste Detail umgesetzt.

Dann sagt der Kunde plötzlich, er wolle ein neues Level des Spiels veröffentlichen, in dem alle Aktionen im Meer stattfinden und die Hauptfigur ein Wal ist.

Als du die „Wal“-Klasse entwirfst, erkennst du, dass sie sich nur geringfügig von der „Kuh“-Klasse unterscheidet. Beide Klassen verwenden eine sehr ähnliche Logik, deshalb entscheidest du dich für die Vererbung.

Die Klasse Cow eignet sich ideal als Elternklasse: Sie hat bereits alle notwendigen Variablen und Methoden. Du musst nur die Fähigkeit des Wals zum Schwimmen hinzufügen. Aber es gibt ein Problem: Dein Wal hat Beine, Hörner und eine Glocke. Schließlich implementiert die Klasse Cow genau diese Funktionalität. Was kannst du da tun?

Das Überschreiben von Methoden ist deine Rettung. Wenn wir eine Methode vererben, die nicht genau das tut, was wir in unserer neuen Klasse benötigen, können wir die Methode durch eine andere ersetzen.

Wie wird das gemacht? In unserer Subklasse deklarieren wir die Methode, die wir ändern wollen (mit der gleichen Methodensignatur wie in der Elternklasse). Dann schreiben wir neuen Code für die Methode. Das war‘s. Das ist dann so, als ob die alte Methode der Elternklasse gar nicht existiert.

So funktioniert es:

class Cow
{
public void printColor()
{
System.out.println("I'm white");
}
public void printName()
{
System.out.println("I'm a cow");
}
}class Whale extends Cow
{
public void printName()
{
System.out.println("I'm a whale");
}
}

public static void main(String[] args)
{
Cow cow = new Cow();
cow.printName();
}

public static void main(String[] args)
{
Whale whale = new Whale();
whale.printName();
}

Nachdem sie von Cow erbt und printName überschreibt, besitzt die Klasse Whale die folgenden Daten und Methoden:

class Whale
{
public void printColor()
{
System.out.println("I'm white");
}
public void printName()
{
System.out.println("I'm a whale");
}
}

„Ehrlich gesagt, genau das habe ich erwartet.“

2) Aber das ist noch nicht alles.

„Angenommen, die Klasse Cow besitzt die Methode printAll, welche die beiden anderen Methoden aufruft. Dann würde der Code folgendermaßen funktionieren:“

Auf dem Bildschirm erscheint:
Ich bin weiß
Ich bin ein Wal

class Cow
{
public void printAll()
{
printColor();
printName();
}
public void printColor()
{
System.out.println("I'm white");
}
public void printName()
{
System.out.println("I'm a cow");
}
}

class Whale extends Cow
{
public void printName()
{
System.out.println("I'm a whale");
}
}

public static void main(String[] args)
{
Whale whale = new Whale();
whale.printAll();
}

Beachte, dass die printName()-Methode von Whale verwendet wird und nicht die von Cow, wenn die printAll ()-Methode der Cow-Klasse mit einem Whale-Objekt aufgerufen wird.

Wichtig ist nicht die Klasse, in der die Methode geschrieben ist, sondern der Typ (die Klasse) des Objekts, mit dem die Methode aufgerufen wird.

„Ach so.“

„Du kannst nur nicht-statische Methoden vererben und überschreiben. Statische Methoden werden nicht vererbt und können daher auch nicht überschrieben werden.“

So sieht die Klasse Whale aus, nachdem wir die Vererbung angewendet und die Methoden überschrieben haben:

class Whale
{
public void printAll()
{
printColor();
printName();
}
public void printColor()
{
System.out.println("I'm white");
}
public void printName()
{
System.out.println("I'm a whale");
}
}

3) Typumwandlung.

Jetzt kommt ein noch interessanterer Punkt. Da eine Klasse alle Methoden und Daten ihrer Elternklasse erbt, kann ein Objekt dieser Klasse von Variablen der Elternklasse (und der Elternklasse der Elternklasse usw., bis hin zur Object-Klasse) referenziert werden. Betrachte dieses Beispiel:

public static void main(String[] args)
{
Whale whale = new Whale();
whale.printColor();
}

public static void main(String[] args)
{
Cow cow = new Whale();
cow.printColor();
}

public static void main(String[] args)
{
Object o = new Whale();
System.out.println(o.toString());
}

„Hört sich gut an. Aber wozu braucht man das?“

„Das ist eine sehr nützliche Funktion. Später wirst du verstehen, dass sie wirklich sehr, sehr nützlich ist.“

4) Dynamische Bindung.

So sieht das aus:

public static void main(String[] args)
{
Whale whale = new Whale();
whale.printName();
}

public static void main(String[] args)
{
Cow cow = new Whale();
cow.printName();
}

Beachte, dass nicht der Typ der Variable bestimmt, welche spezifische printName-Methode wir aufrufen (die der Klasse Cow oder Whale), sondern der Typ des von der Variable referenzierten Objekts.

Die Cow-Variable speichert eine Referenz auf ein Whale-Objekt, und die in der Whale-Klasse definierte printName-Methode wird aufgerufen.

„Naja, das haben sie wegen der Klarheit nicht hinzugefügt.“

„Ja, das ist nicht so offensichtlich. Merke dir diese wichtige Regel:“

Die Auswahl der Methoden, die du über eine Variable aufrufen kannst, wird durch den Typ der Variable bestimmt. Welche spezifische Methode/Implementierung aufgerufen wird, wird jedoch durch den Typ/die Klasse des von der Variable referenzierten Objekts bestimmt.

„Ich werde es versuchen.“

„Du wirst ständig damit konfrontiert, also wirst du es schnell verstehen und nie mehr vergessen.“

5) Typumwandlung.

Die Typumwandlung funktioniert bei Referenztypen, also Klassen, anders als bei primitiven Typen. Allerdings gelten auch für Referenztypen erweiternde und einschränkende Umwandlungen. Betrachte dieses Beispiel:

Cow cow = new Whale();

Cow cow = new Whale();
if (cow instanceof Whale)
{
Whale whale = (Whale) cow;
}

Cow cow = new Cow();
Whale whale = (Whale) cow; //exception

6) Und nun zu einem echten Leckerbissen. Ursprüngliche Methode aufrufen.

Manchmal möchte man beim Überschreiben einer geerbten Methode diese nicht vollständig ersetzen. Manchmal möchte man sie einfach nur ein bisschen ergänzen.

In diesem Fall möchtest du, dass der Code der neuen Methode die gleiche Methode aufruft, aber über die Basisklasse. Mit Java ist auch das möglich. Und so wird es gemacht: super.method().

Hier ein paar Beispiele:

class Cow
{
public void printAll()
{
printColor();
printName();
}
public void printColor()
{
System.out.println("I'm white");
}
public void printName()
{
System.out.println("I'm a cow");
}
}

class Whale extends Cow
{
public void printName()
{
System.out.print("This is false: ");
super.printName();

System.out.println("I'm a whale");
}
}

public static void main(String[] args)
{
Whale whale = new Whale();
whale.printAll();
}

„Hmm. Okay, das war eine tolle Lektion. Meine Roboter-Ohren sind fast geschmolzen.“

„Ja, das ist kein einfaches Zeug. Das ist eines der schwierigsten Themen, auf das du stoßen wirst. Der Professor hat versprochen, Links zu Materialien anderer Autoren bereitzustellen, so dass du deine Verständnislücken schließen kannst.“