Wir beginnen mit einem einfachen Beispiel, in dem wir zu einer Oberklasse (Tier) zwei Unterklassen (Katze, Hund) bilden:

Einer Variablen vom Typ Tier können wir sowohl Hund-Objekte als auch Katze-Objekte zuordnen. In beiden Fällen können wir die Methode stellDichVor() der Klasse Tier aufrufen:

Tier t; 
t = new Katze("Snoopy");
t.stellDichVor();
 
t = new Hund("Bello");
t.stellDichVor();

Die Variable t kann sowohl auf ein Hund-Objekt zeigen als auch auf ein Katze-Objekt. Diesen Sachverhalt nennt man Polymorphismus. Das Wort kommt aus dem Griechischen und bedeutet "Vielgestaltigkeit".

Wir erweitern die Klasse Katze um eine Methode miaue und die Klasse Hund um eine Methode belle:

Können wir diese Methoden mit Hilfe der Variable t aufrufen?

Tier t; 
t = new Katze("Snoopy");
t.miaue(); // GEHT NICHT!
 
t = new Hund("Bello");
t.belle(); // GEHT NICHT!

Obwohl die Variable t zum Zeitpunkt des Aufrufes t.schnurre() auf ein Katze-Objekt zeigt, akzeptiert der Compiler diesen Aufruf nicht, denn die Deklaration Tier t in der ersten Zeile sichert nur zu, dass t auf ein Objekt der Klasse Tier oder einer Unterklasse davon zeigt.

casten:
Aber wir wissen doch, dass beide Aufrufe in Ordnung sind. Können wir das dem Compiler nicht mitteilen?

Tier t; 
t = new Katze("Snoopy");
((Katze)t).miaue(); // OK!
 
t = new Hund("Bello");
((Hund)t).belle(); // OK!
((Katze)t).miaue(); // Führt zur Laufzeit zu einem Fehler!