Override und Vererbung: So lassen sich Java Methoden überschreiben

Hier ein paar Eckdaten zur Uhr:

• Höhe des Turmes 601 m.
• Das Ziffernblatt der Turmuhr hat einen Durchmesser von 43 Meter
• Die Länge des Minutenzeigers beträgt 24 Meter
• und die Länge des Stundenzeigers 17 Meter.

Ist schon Wahnsinn, oder?
Kaum vorstellbar, wie man dieses Teil bauen, liefern und montieren konnte.

Doch jetzt kommt’s…
Es war ein deutsches Unternehmen, welches diese Uhr baute und lieferte.
Und zwar ein 30-Mann-starker deutscher Mittelständer aus Calw, Baden Würthenberg.
Die Firma trägt den grundsoliden Namen „Perrot Turmuhren und Läuteanlagen“.

„Ich find es total geil, dass deutsche Unternehmen solche Geschichten schreiben.“

Aber warum erzähl ich dir das?
In diesem Beitrag geht es nur am Rande um Turmuhren.
Stattdessen möchte ich das Uhrenbeispiel dazu verwenden, Java Methoden zu überladen.

Aber noch mehr…
Es geht in diesem Beitrag um Vererbung und darum weiter vererbte Java Methoden zu überschreiben.
Du lernst, was du beim Überschreiben von Java Methoden beachten musst.
Außerdem schauen wir uns die Annotationen zum Overriding an und was diese bewirken.

Java Methoden überschreiben – Hier am Beispiel einer Uhr.

Also ich spinne das Beispiel mit der Turmuhr einmal weiter.

Dazu erstelle ich eine Java Klasse, namens Turmuhr.

public class Uhr {
 
}

Was kann die Uhr?
Uhren können läuten.
Natürlich können sie auch die Uhrzeit anzeigen.

Okay und was brauchen wir dafür?
Ein Läutgeräusch kannst du in einen String speichern.
Und natürlich benötigst du eine Variable für die Uhrzeit.

import java.util.Calendar;//Importanweisung für Calendar
 
public class Uhr {
String laeutGeraesch;// Klingelton der Uhr
Calendar uhrZeit = Calendar.getInstance();//Objekt der Klasse Calendar
 
}
 

Die Klasse hat nun zwei Instanzvariablen.
Wobei die Variable für die Uhrzeit, ein Objekt der Klasse Calendar ist.

Da die Calendar Klasse eine Standardklasse aus der Java Bibliothek ist, kannst du jederzeit per Import-Anweisung darauf zugreifen.
Doch beachte, dass die Klasse Calendar eine abstrakte Klasse ist und somit das Anlegen von Objekten einschränkt.
Falls du den Artikel zur Klasse Calendar verpasst hast, klicke später hier.

Mal ganz ehrlich – Braucht jede Uhr eine Uhrzeit?

Die Frage ist vielleicht blöd gestellt.
Aber – Ist es notwendig, dass jede Uhr ihre eigene Uhrzeit bzw. Zeitrechnung hat?

Oder ist es nicht eher so, dass es nur eine wahre Zeitrechnung gibt.
Und alle Uhren messen diese bzw. greifen auf diese zurück.
Was denkst du?

Du siehst – Bei der Java Programmierung kommt es nicht nur auf den Code an.
Vielmehr spielen Denk- und Abstraktionsmodelle eine Rolle.

Ich bin der Meinung, dass nicht jede Uhr eine eigene Uhrzeit braucht.
Somit braucht auch nicht jedes Uhr-Objekt eine eigene Instanzvariable für die Zeit.

Deshalb schaffen wir später eine globalere Variable für die Zeit, welche alle Uhren nutzen.
Vorerst kannst du die Instanzvariable löschen oder so wie ich – einfach auskommentieren.

import java.util.Calendar;
 
public class Uhr {
String laeutGeraesch;
//Calendar uhrZeit = Calendar.getInstance();//Objekt der Klasse Calendar
 
}

So legst du die Java Methoden zur Uhrzeit an.

So die eine Instanzvariable bleibt über.
Jetzt kannst du die Objektmethoden für die Uhr implementieren.

import java.util.Calendar;//Importanweisung für Calendar

public class Uhr {
String laeutGeraesch;
 
void laeuten(){
System.out.println(laeutGeraesch);
}
 
void gibZeit(Calendar uhrzeit){
System.out.println(uhrzeit.get(Calendar.HOUR_OF_DAY)+":"+uhrzeit.get(Calendar.MINUTE));
}
 
}

Du siehst – Ich halte es einfach.

• Alle Methoden erzeugen lediglich Bildschirmausgaben und sind deshalb void-Methoden, ohne Rückgabewerte.
• Die Läuten-Methode liest lediglich den Wert der Instanzvariablen aus und gibt diesen auf der Konsole zurück.
• Und die gibZeit()-Methode erwartet ein Calendar-Objekt in ihrer Parameterliste.
  Dieses Objekt nimmt sie dann und gibt die Werte für die Uhrzeit auf der Konsole aus.

Ich will es noch Einfacher.

Und deshalb fasse ich beide Java Methoden zusammen.

Dies ist für diesen Artikel besser, denn es geht schließlich nur um die Methoden.
Und bei zwei Methoden, schleppe ich immer eine mit.
Dadurch wird der Lerninhalt nur aufgebläht und dadurch unnötig kompliziert.

Also hier ist die Uhren-Klasse mit einer Methode, welche bei jeder Zeitangabe – gleichzeitig Geräusche macht.

import java.util.Calendar;
 
public class Uhr {
String laeutGeraesch;
 
void laeuten(Calendar uhrzeit) {
System.out.println(laeutGeraesch);
System.out.println(uhrzeit.get(Calendar.HOUR_OF_DAY) + ":" + uhrzeit.get(Calendar.MINUTE));
}
}

Lass uns das Beispiel jetzt testen.

Und deshalb erstelle ich eine weitere Klasse „Uhren-Simulator“.
Diese Klasse enthält die main-Methode, um das Java Programm zu starten.

public class UhrenSimulator {
 
public static void main(String[] args) {
 
}
}

Dann lass uns einmal zwei Uhren Objekte anlegen und die Methode aufrufen.
Hier nochmal die Klasse „Uhr“.

import java.util.Calendar;
 
public class Uhr {
String laeutGeraesch;
 
void laeuten(Calendar uhrzeit) {
System.out.println(laeutGeraesch);
System.out.println(uhrzeit.get(Calendar.HOUR_OF_DAY) + ":" + uhrzeit.get(Calendar.MINUTE));
}
}

Und der Uhren-Simulator mit zwei Uhren.

import java.util.Calendar;
 
public class UhrenSimulator {
 
public static void main(String[] args) {
Uhr uhr1 = new Uhr();//Objekt der Klasse Uhr
Uhr uhr2 = new Uhr();//Noch Objekt der Klasse Uhr
 
//Die Methode benötigt beim Aufruf ein Calendar-Objekt
Calendar cal = Calendar.getInstance();//Objekt der Klasse Calendar
 
uhr1.laeutGeraesch="DING";//Zuweisung des Lautgeräusches für die erste Uhr
uhr2.laeutGeraesch="Piep";//Zuweisung Wert der Instanzvariablen für Uhr 2
 
uhr1.laeuten(cal);//Aufruf der Methode für Objekt 1 mit Calendar-Objekt
uhr2.laeuten(cal);//Aufruf der Methode für 2 Objekt mit dem gleichen Calendar-Objekt
}
}

Beachte bitte:
Die Methode führt in der Parameterliste ein Calendar-Objekt, namens „uhrzeit“.
Und deshalb musst du ihr beim Aufruf auch ein Calendar-Objekt übergeben.

• Beim Aufruf der Methode für uhr1 – erscheint ein „DING-Ton“ und dann die Uhrzeit.
• Und beim Aufruf der Methode für die uhr2 – erscheint der „Piep-Ton“ und schließlich ebenfalls die Uhrzeit.

Läuft, oder?
Okay, die Otto-Normal-Verbraucher-Uhr haben wir.
Jetzt kommen die speziellen Uhren, Turmuhr und Taschenuhr.

Eine Möglichkeit die Java Methoden zu erweitern, bietet das Überladen.

Angenommen du erstellst jetzt eine Turmuhr.
Und diese läutet nicht „DING“, sondern „DONG“.

Dann kannst du der Instanzvariablen für das Geräusch, ganz einfach einen anderen Wert zuweisen.
Somit macht die eine Uhr Ding und die andere Dong.

Was aber, wenn es etwas komplizierter wird?
Zum Beispiel, könnte doch die Turmuhr mehrmals läuten.

Denn ist es nicht so, dass eine Turmuhr gewöhnlich mehrmals klingelt?
Denn durch das Läuten verkündet die Uhr, auch akustisch die Uhrzeit.

• Ist es 12 Uhr läutet die Turmglocke 12-mal.
• Und ist es 2 Uhr läutet sie lediglich 2 mal.

Was machst du nun mit der läuten-Methode?
Du benötigst diese auf einmal in 2 Varianten.

• Einmal für normale Uhren mit leisen Piepen.
• Und einmal für Turmuhren mit lauten Dong und Wiederholungen.

Also wie geht das?
Klar, du kannst jede Java Methode überladen.
Und so auch die läuten-Methode.

Dazu musst du nur die Methode mit zwei unterschiedlichen Parameterlisten führen.

• Die erste Methode bleibt so, wie sie ist.
• Und die zweite bekommt noch einen weiteren Parameter dazu.

Nur welcher Parameter passt dazu?
Vielleicht ein boolean.

• Wenn dieser true ist, wird mehrmals geläutet.
• Und wenn dieser false ist, wird nur einmal geläutet.

import java.util.Calendar;
 
public class Uhr {
String laeutGeraesch;
 
void laeuten(Calendar uhrzeit) {
System.out.println(laeutGeraesch);
System.out.println(uhrzeit.get(Calendar.HOUR_OF_DAY) + ":" + uhrzeit.get(Calendar.MINUTE));
}
 
//Zweite Methode mit gleicher Signatur nur mit mehr Parameter
void laeuten(Calendar uhrzeit, boolean mehrMalsLaeuten) {
//Falls boolean = true läute mehrmal, ansonsten nur einmal
}
}

Überleg mal.
Es ist doch Quatsch. Denn diese Methode soll immer mehrmals läuten.
Dafür haben wir sie doch gemacht, oder?

Jetzt würde beim Aufruf entschieden werden, ob der boolean true oder false ist.
Und erst dann würde die Methode – einmal oder mehrmals läuten.

Jetzt stellt sich die Frage: Was wollen wir eigentlich?

Klar, wir wollen einmal normale Uhren abbilden.
Diese sollen die Uhrzeit zeigen.

Und wir wollen speziellere Uhren, wie Turmuhren modellieren.
Diese sollen dann, in Abhängigkeit von der aktuellen Stundenanzahl, öfter läuten.

Wie du selbst siehst, stößt du mit dem Überladen von Methoden auf Grenzen.
Aber, es gibt in Java ein sehr mächtiges Feature.
Und dieses Feature erlaubt es dir, für spezielle Objekte – spezielle Methoden zu erschaffen.

Dieses Feature nennt sich Vererbung.
Dabei ist es dir möglich:

• Eine Standardmethode für stinknormale Uhren anzubieten
• Und eine speziellere Methode für speziellere Uhren

Java Methoden und Vererbung im Zusammenspiel

Also bilden wir doch einmal zwei speziellere Klassen:

• Turmuhr mit der speziellen Läutmethode
• Und Taschenuhr mit einer anderen spezielleren Läutmethode.

So erstellst du spezielle Klassen mit speziellen Java Methoden

Du benötigst jetzt eine Klasse Taschenuhr und eine Klasse Turmuhr.
Und beide erweitern die Klasse Uhr.

public class Turmuhr extends Uhr{

}

public class Taschenuhr extends Uhr{

}

So kannst du Java Methoden überschreiben.

Jetzt kannst du die Methoden einfach in der Klasse anbieten.
So wie ich:

import java.util.Calendar;

public class Taschenuhr extends Uhr {

	// laeuten-Methode wurde aus der Superklasse Uhr überschrieben
	void laeuten(Calendar uhrzeit) {
		System.out.println(laeutGeraesch);
		System.out.println(uhrzeit.get(Calendar.HOUR_OF_DAY) + ":" + uhrzeit.get(Calendar.MINUTE));
	}
}

Diese Methode macht genau das Gleiche, was die Methode in der Superklasse „Uhr“ auch macht.
Einmal klingeln und Uhrzeit anzeigen.

Die Turmuhr-Methode macht da schon mehr.

import java.util.Calendar;

public class Turmuhr extends Uhr {

	//laeuten Methode wurde aus der Superklasse Uhr überschrieben
	void laeuten(Calendar uhrzeit) {
		for (int i = 0; i < uhrzeit.get(Calendar.HOUR); i++) {
			System.out.println(laeutGeraesch);
		}
		System.out.println(uhrzeit.get(Calendar.HOUR_OF_DAY) + ":" + uhrzeit.get(Calendar.MINUTE));
	}
}

Vielleicht möchtest du die Taschenuhr-Methode auch anpassen.
Diese könnte im 24-Stunden Modus piepen.

Dann mach es genauso wie ich und platziere im Rumpf eine for-Schleife.

Die Durchläufe sollten dann aber nicht maximal 12, sondern 24 sein.
Also ersetze HOUR durch HOUR_OF_DAYS in der Abruchbedingung.

Jetzt lass uns ein paar Kindklassen-Objekte erstellen und die Methoden testen.

Hier ist die Klasse Uhren-Simulator mit neuen Objekten.

import java.util.Calendar;//Importanweisung für den Calendar

public class UhrenSimulator {

	public static void main(String[] args) {
		Taschenuhr uhr1 = new Taschenuhr();//neues Objekt der Klasse Taschenuhr
		Turmuhr uhr2 = new Turmuhr ();//neues Objekt der Klasse Turmuhr
		Uhr uhr3 = new Uhr();//stinknormale Uhr
		Calendar cal = Calendar.getInstance();//Calendar-Objekt für die Methodenaufrufe
		
		uhr1.laeutGeraesch="PIEP";
		uhr2.laeutGeraesch="DONG";
		uhr3.laeutGeraesch="DING";
		
		uhr1.laeuten(cal);//Aufruf der Läuten-Methode aus der Taschenuhr-Klasse
		uhr2.laeuten(cal);//Aufruf der Läuten-Methode für Turmuhren
		uhr3.laeuten(cal);//Aufruf für stinknormale Uhren
	}
}

Klicke auf RUN und genieß die Show.

• Uhr1 ist eine Taschenuhr.
  Beim Aufruf der Methode uhr1.laeuten(), macht diese einmal „PIEP“ und zeigt dann die Uhrzeit an.
• Uhr2 ist die Turmuhr.
  Die Methode macht schon mehrmals „DONG“. Und zwar in Abhängigkeit von der Uhrzeit. Bei mir ist es gerade 9:42 Uhr. Somit erscheinen 9 Dongs.
• Uhr3 ist eine x-beliebige Uhr und macht das Gleiche, was die Taschenuhr auch macht.
  Der Unterschied besteht lediglich im Läutgeräusch.

Beim Aufruf der einzelnen Methoden, wird der Ursprung über die Auswahlliste deutlich.

• Gib einfach in Eclipse – uhr1 und den Punkt ein.
  Die Auswahl öffnet sich.
• Dann gib noch ein „L“ für „läuten“ ein.
  Die Methode wird dir angezeigt.
• Dann steht rechts neben dem Methodennamen, die Aufrufklasse.
• Vollzieh das Ganze für alle drei Objekte.

Jetzt siehst du, dass für uhr1 der Ursprung in der Klasse Taschenuhr liegt.
Für uhr2 liegt der Aufruf in der Klasse Turmuhr.
Und schließlich ist die Methode für uhr3 in der Superklasse Uhr zu finden.

Und dies beweist:

Du hast die Läuten-Methode der Superklasse in den Kindklassen überschrieben.

So lassen sich die Kindklassen um zusätzliche Java Methoden erweitern.

import java.util.Calendar;

public class Taschenuhr extends Uhr {

	void laeten(Calendar uhrzeit) {
		System.out.println(laeutGeraesch);
		System.out.println(uhrzeit.get(Calendar.HOUR_OF_DAY) + ":" + uhrzeit.get(Calendar.MINUTE));
	}
}

Du bemerkst meinen Fehler?
In der Klasse Taschenuhr lautet der Methodenname auf einmal „laeten“ – und nicht „laeuten“.
Scheinbar gibt es damit aber kein Problem.

Du kannst die laeten-Methode, völlig problemlos am Objekt aufrufen.
So wie hier in der Programmstart-Klasse.

import java.util.Calendar;

public class UhrenSimulator {

	public static void main(String[] args) {
		Taschenuhr uhr1 = new Taschenuhr();
		Turmuhr uhr2 = new Turmuhr ();
		Uhr uhr3 = new Uhr();
		Calendar cal = Calendar.getInstance();
		
		uhr1.laeutGeraesch="PIEP";
		uhr2.laeutGeraesch="DONG";
		uhr3.laeutGeraesch="DING";
		
		uhr1.laeten(cal);//Aufruf der laeten-Methode
	}
}

Java bzw. der Compiler bemerkt den Fehler überhaupt nicht.

Also was ist das jetzt?
Die Methode „laeten()“ ist in der Ober- oder Superklasse gar nicht bekannt.
Es handelt sich um eine komplett neue Methode, der Kindklasse „Taschenuhr“.

• Armband
• Datumsanzeige
• Stoppfunktionen auftauchen.

Diese Möglichkeiten hätte dann nur die Taschenuhr.

import java.util.Calendar;

public class Taschenuhr extends Uhr {

	void laeuten(Calendar uhrzeit) {
		System.out.println(laeutGeraesch);
		System.out.println(uhrzeit.get(Calendar.HOUR_OF_DAY) + ":" + uhrzeit.get(Calendar.MINUTE));
	}

	void laeten(Calendar uhrzeit) {
		System.out.println(uhrzeit.get(Calendar.DAY_OF_MONTH) + "." + uhrzeit.get(Calendar.MONTH) + "."
				+ uhrzeit.get(Calendar.YEAR));
	}
}

Und in der Programmstartklasse könntest du dann, beide Methoden am Objekt aufrufen.

import java.util.Calendar;

public class UhrenSimulator {

	public static void main(String[] args) {
		Taschenuhr uhr1 = new Taschenuhr();
		Turmuhr uhr2 = new Turmuhr ();
		Uhr uhr3 = new Uhr();
		Calendar cal = Calendar.getInstance();
		
		uhr1.laeutGeraesch="PIEP";
		uhr2.laeutGeraesch="DONG";
		uhr3.laeutGeraesch="DING";
		
		uhr1.laeuten(cal);//Uhrzeit
		uhr1.laeten(cal);//Datum
	}
}

Nochmal:

• Weder die Superklasse Uhr, noch die parallel abgeleitete Kindklasse Turmuhr – wüssten von den Möglichkeiten.
  Und selbstverständlich könnten sie diese auch nicht nutzen.
• Somit kannst du die neue Datums-Methode nur am Taschenuhr-Objekt ( uhr1 ) aufrufen.

So nutzt du die Override Annotation beim Überschreiben von Java Methoden

Aber mal ehrlich – Laeten als Methodenname ist schon blöd, oder?

Was hier passiert ist, war ein Schreibfehler.
Denn die Methode laeten() sollte keine eigenständige Methode der Kindklasse sein.
Stattdessen sollte sie wirklich die Methode der Superklasse überschreiben bzw. erweitern.

Solche Schreibfehler können passieren.
Und schwuppdiwupp hast du eine eigenständige neue Methode.
Und du weißt es nicht mal.

Aber du kannst dich schützen.
Und zwar mit einer Annotation.

import java.util.Calendar;

public class Taschenuhr extends Uhr {

	@Override
	void laeuten(Calendar uhrzeit) {
		System.out.println(laeutGeraesch);
		System.out.println(uhrzeit.get(Calendar.HOUR_OF_DAY) + ":" + uhrzeit.get(Calendar.MINUTE));
	}
	@Override
	void laeten(Calendar uhrzeit) {
		System.out.println(uhrzeit.get(Calendar.DAY_OF_MONTH) + "." + uhrzeit.get(Calendar.MONTH) + "."
				+ uhrzeit.get(Calendar.YEAR));
	}
}

Du musst lediglich die Annotation – @Override – vor der Methode einfügen.

• erweiterten Java Methoden der Superklasse
• und neuen Methoden oder Schreibfehlern

So alle Fehlerquellen ausgeschlossen?
Nicht ganz.

Beim Erweitern oder Überschreiben von Java Methoden solltest du auf den Scope achten.

Mit Scope ist die Sichtbarkeit gemeint.
Es gibt vier unterschiedliche Stufen, welche für die Sichtbarkeit von Java Methoden eine Rolle spielen.
Um diese Sichtbarkeit einzustellen, stellst du einen sogenannten Access Modifiers voran.

Stufe 1 public – Die Java Methode ist öffentlich.

Die Methode ist überall sichtbar und kann überall verwendet werden.
Sie ist somit auch in der Kindklasse sichtbar und kann dort überschrieben werden.
Was du allerdings beachten musst, ist:

Wenn die Methode in der Superklasse public ist – dann muss die überschriebene Methode in der Kindklasse ebenfalls public sein.

Stufe 2 protected – Die Java Methode ist im gleichen Vererbungsbaum sichtbar.

Taschenuhr und Uhr liegen in der selben Vererbungslinie, denn Taschenuhr erweitert (extends) Uhr.
Somit kannst du auch hier die Methode überschreiben und nutzen.
Es ist wieder wichtig, dass beide Methoden den gleichen Access Modifiers vorangestellt bekommen.

Stufe 3 package private – Die Java Methode ist im gleichen Package sichtbar.

Package private ist der einzige Access Modifiers, ohne Schlüsselwort.
Diese Sichtbarkeitsstufe haben wir bei der läuten-Methode bereits angewendet.
Wenn die abgeleitete Klasse im selben Package, wie die Superklasse ist – kann die Methode überschrieben werden.

Stufe 4 private – Die Java Methode ist nur in der Superklasse sichtbar.

Und somit kannst du diese Methode in der Kindklasse nicht überschreiben.

Wo liegt der Unterschied zwischen Überladen und Überschreiben von Java Methoden

So das war für heute eine ganze Menge, oder?
Und wahrscheinlich ist dir nicht mehr ganz klar, welcher Unterschied zwischen dem Überladen und Überschreiben besteht.
Deshalb habe ich noch zwei Bilder für Dich.

Überladene Java Methoden gehen in die Breite

Nochmal Überladen bedeutet:

Java Methoden mit verschiedenen Parameterlisten anbieten.

Überschriebene Methoden gehen in die Tiefe.

Überschreiben bedeutet:

Einfache Java Methoden spezieller machen und diese für abgeleitete Objekte anbieten. (Vererbung)

Dadurch kannst du zum Beispiel Taschenuhren-Methoden anbieten, welche den Parameter taschenuhrenspezifisch verarbeiten.

Zusammenfassung:

• Durch Vererbung können allgemeine Java Methoden der Superklassen überschrieben werden.
• Dadurch werden diese spezieller und können, wie eine Schablone, angepasst werden.
• Außerdem kannst du in erweiterten Klassen zusätzliche Methoden implementieren, welche die Superklasse nicht einmal kennt.
• Das Zusammenspiel zwischen Vererbung und Methoden ermöglicht dir eine hohe Flexibilität und Erweiterung deiner Java Programme.

Über den Autor

Folge Sciodoo und bleibe stets auf dem Laufenden. Schließ dich uns an und abonniere unseren Instagram-Kanal ein. Wir stellen täglich neue Artikel für dich rein. Weiter zum Kanal>>>