In Java vererbt eine Vaterklasse ihre Interfaces an ihre Tochterklassen.
Sind von der Vaterklasse bereits alle Interface-Methoden implementiert worden, muss in den Tochterklassen keine Methode zusätzlich nachimplementiert werden.
Es ist aber erlaubt, dass die Tochterklassen eigene Versionen der Interface-Methoden implementieren, falls dies erforderlich sein sollte.
Wir möchten nun das Vererben von Interfaces in Java testen, dazu schreiben wir eine kleine Anwendung, bei der das Interface der Vaterklasse an die abgeleitete Tochterklasse vererbt wird. Die Tochterklasse soll dabei noch ein zweites Interface zusätzlich implementieren und eine Interface-Methode der Vaterklasse überlagern.
Der folgende Quellcode definiert die Vaterklasse Tisch, welche das Interface Transportierbar implementiert. Eine detaillierte Beschreibung des Interfaces Transportierbar wird in dem Beitrag Interfaces – Verwendung von Schnittstellen in Java gegeben.
Beispielanwendung: Die Tisch-Klasse implementiert das Interface
/*
* Beispielanwendung: die Tisch-Klasse implementiert das Interface Transportierbar
*/
public class Tisch implements Transportierbar
{
public String kennzeichnung;
public boolean zerbrechlich;
public float gewicht, laenge, hoehe, breite;
public Tisch (String name, boolean zerbrechlich, float gewicht, float laenge, float breite, float hoehe)
{
kennzeichnung = name;
this.zerbrechlich = zerbrechlich;
this.gewicht = gewicht;
this.laenge = laenge;
this.breite = breite;
this.hoehe = hoehe;
}
public float gewicht()
{
return gewicht;
}
public float laenge()
{
return laenge;
}
public float breite()
{
return breite;
}
public float hoehe()
{
return hoehe;
}
public boolean zerbrechlich()
{
return zerbrechlich;
}
public String beschriftung()
{
String text = "Tisch " + kennzeichnung;
return text;
}
}
Das Interface Transportierbar wird mit dem unten angegebenen Quellcode definiert:
Beispielanwendung: Das Interface Transportierbar
/*
* Beispielanwendung: das Interface Transportierbar
*/
public interface Transportierbar
{
public final float MAX_GEWICHT_PRO_FLAECHE = 29.99F;
// hier geht auch: float MAX_GEWICHT_PRO_FLAECHE = 29.99F;
// alle Methoden in Interfaces sind implizit public und abstract
// alle vier Methodendeklarationen sind zulässig
// jede dieser Methoden ist public und abstract
float gewicht();
abstract float laenge();
public float breite();
public abstract float hoehe();
boolean zerbrechlich();
String beschriftung();
}
Als nächstes möchten wir die Klasse Kindertisch definieren, die von der Klasse Tisch das Interface Transportierbar erbt. Dazu müssen wir nur die neue Klasse mit Hilfe des Schlüsselworts extends von der Klasse Tisch ableiten.
Dadurch erbt die neue Klasse automatisch das Interface der Vaterklasse. Da die Klasse Tisch das Interface Transportierbar bereits vollständig implementiert, müssen keine Interface-Methoden von der abgeleiteten Klasse Kindertisch implementiert werden.
Unsere neue Klasse Kindertisch soll neben dem geerbten Interface das Interface Comparable zusätzlich selbst implementieren. Dies geschieht mit Hilfe des Schlüsselworts implements und indem wir die Interface-Methode compareTo(Object obj) in unserer neuen Klasse implementieren.
Der folgende Quellcode definiert die neue Klasse Kindertisch, in der nun das geerbte Interface Transportierbar und das selbst implementierte Interface Comparable verfügbar sind.
Beispielanwendung: Kindertisch-Klasse erbt Interface Transportierbar
/*
* Beispielanwendung: die Kindertisch-Klasse erbt das Interface Transportierbar,
* implementiert das Interface Comparable und überlagert
* die Methode beschriftung()
*/
public class Kindertisch extends Tisch implements Comparable
{
public Kindertisch (String name, boolean zerbrechlich, float gewicht, float laenge, float breite, float hoehe)
{
super(name, zerbrechlich, gewicht, laenge, breite, hoehe);
}
public String beschriftung()
{
String text = "Kindertisch " + kennzeichnung;
return text;
}
public int compareTo(Object obj)
{
float breite = 0;
int ergebnis = 0;
if (obj instanceof Tisch)
{
breite = ((Tisch) obj).breite;
}
if (this.breite < breite)
{
ergebnis = -1;
}
else if (this.breite > breite)
{
ergebnis = 1;
}
return ergebnis;
}
}
Die neue Klasse Kindertisch hat das Interface Transportierbar von seiner Vaterklasse Tisch geerbt. Da die Vaterklasse bereits alle Interface-Methoden implementiert hat, kann das geerbte Interface sofort verwendet werden.
Wir haben aber trotzdem eine kleine Änderung vorgenommen und die Interface-Methode beschriftung() in der abgeleiteten Klasse Kindertisch neu implementiert. Somit wird die Methode beschriftung() der Vaterklasse jetzt von unserer neuen Methodenversion überlagert.
Um unsere Anwendung zu testen, benötigen wir noch eine Testklasse. Die wollen wir nun definieren. Mit dem folgenden Quellcode wird unsere Testklasse InterfaceTest implementiert:
Beispielanwendung: Die Testklasse für das Interface
/*
* Beispielanwendung: die Testklasse für das Interface
*/
public class InterfaceTest
{
public static String erstelleBeschriftung (Transportierbar tDetails)
{
return tDetails.beschriftung();
}
public static void main (String[] args)
{
// erzeugen der Objekte
Kindertisch kindertischKTisch = new Kindertisch ("KT1",false,2.3F,1.5F,1.5F,1.3F);
Transportierbar transpTisch = new Tisch ("T1", false,5.0F,3.0F,2.5F,1.5F);
Transportierbar transpKTisch = new Kindertisch ("KT2",false,2.4F,2.1F,2.1F,2.1F);
Comparable compKTisch = new Kindertisch ("KT3",false,2.8F,2.2F,2.2F,2.2F);
System.out.println("\nAufdruck: " + erstelleBeschriftung(kindertischKTisch));
System.out.println("Aufdruck: " + erstelleBeschriftung(transpTisch));
System.out.println("Aufdruck: " + erstelleBeschriftung(transpKTisch));
int ergebnis = kindertischKTisch.compareTo(compKTisch);
System.out.print("\nVergleich Kindertisch KT1 mit KT3: " + ergebnis);
}
}
Zu Beginn erzeugen wir vier Objekte (3 Objekte vom Typ Kindertisch und 1 Objekt vom Typ Tisch). Die vier Objekte werden in Referenzvariablen vom Typ Kindertisch, Transportierbar und Comparable abgespeichert.
Anschließend werden alle Objekte, die kompatibel zum Interface Transportierbar sind, an die Methode erstelleBeschriftung(Transportierbar tDetails) übergeben.
In der Methode wird die Interface-Methode beschriftung() über das jeweilige Objekt aufgerufen, welches in der lokalen Objektvariable tDetails vom Typ Transportierbar ist, und die Beschriftung ausgegeben.
Danach wird die Interface-Methode compareTo(Object obj) auf der Objektvariable kindertischKTisch aufgerufen, die kompatibel zu dem Interface Comparable ist, und das Ergebnis des Vergleichs ausgegeben.
Hinweis: Der Typ der Objektvariable legt fest, welche Methoden (auch Interface-Methoden) aufgerufen werden können. Der Typ des Objekts entscheidet, welche Methodenversion ausgeführt wird.
Starten wir nun die Beispielanwendung. In der unteren Abbildung ist die Kommandozeilenausgabe des Programms dargestellt:
Vererbung von Interfaces in Java – Ausgabe der Beispielanwendung
Mit dem folgenden Link gelangt ihr zurück zum Java Kurs.
Comments 1
Pingback: Interfaces (Schnittstellen) in Java