Ein Interface an ein anderes Interface vererben – Ableiten von Interfaces in Java

In Java kann ein Interface seine Eigenschaften an andere Interfaces vererben.

Wie bei der normalen Vererbung erbt dabei das abgeleitete Interface alle Methoden und Konstanten des Basis-Interfaces.

Soll eine Klasse ein abgeleitetes Interface implementieren, muss sie alle Methoden dieses Interfaces und des übergeordneten Super-Interfaces implementieren.

---

Unser großes
Android Online-Kurs
Gesamtpaket

---

Ideal für den praxisnahen Einstieg in die Entwicklung von Android Apps Besonders einsteigerfreundlich - jeder Arbeitsschritt ist exakt dokumentiert Enthält alle 35 Lektionen unseres Android Apps Programmieren Kurses Enthält alle 8 Lektionen unseres SQLite Datenbank App Programmieren Kurses

---

Weitere Infos

---

Wir möchten nun ein neues Interface definieren, das sich von dem Interface Comparable ableitet und einige eigene Methoden definiert. In folgendem Quellcode ist das neue Interface TransportAndComparable definiert:

Beispielanwendung: Das Interface TransportAndComparable

/*
* Beispielanwendung: das Interface TransportAndComparable
*/

public interface TransportAndComparable extends Comparable
{
  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();
}

Unsere Klasse Tisch soll nun unser neues Interface TransportAndComparable implementieren:

Beispielanwendung: Die Tisch-Klasse implementiert das Interface

/*
* Beispielanwendung: die Tisch-Klasse implementiert das Interface TransportAndComparable
*/

public class Tisch implements TransportAndComparable
{
  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;
  }

  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;
  }
}

Um das neue Interface TransportAndComparable zu testen, schreiben wir eine einfache Testanwendung. Hierzu definieren wir die Testklasse InterfaceTest:

Beispielanwendung: Die Testklasse für das Interface

/*
* Beispielanwendung: die Testklasse für das Interface TransportAndComparable
*/

public class InterfaceTest
{
  public static void main (String[] args)
  {
    // erzeugen der Tisch-Objekte
    Tisch tischTisch               = new Tisch ("Esstisch", false, 27.3F, 3.0F, 2.2F, 1.3F);
    TransportAndComparable tcTisch = new Tisch ("Wandtisch", false, 15.0F, 2.0F, 1.5F, 1.0F);


    int a = tischTisch.compareTo(tcTisch);
    System.out.println("\nVergleich tischTisch mit tcTisch:    " + a);

    a = tcTisch.compareTo(tischTisch);
    System.out.println("Vergleich tcTisch mit tischTisch:   " + a);

    TransportAndComparable tcObjekt = tischTisch;

    System.out.println("\nDaten tischTisch Objekt:");
    float volumen = tcObjekt.laenge()*tcObjekt.breite()*tcObjekt.hoehe();
    System.out.println("Volumen:      " + volumen + " m^3");
    System.out.println("Beschriftung: " + tcObjekt.beschriftung());


    tcObjekt = tcTisch;

    System.out.println("\nDaten tcTisch Objekt:");
    volumen = tcObjekt.laenge()*tcObjekt.breite()*tcObjekt.hoehe();
    System.out.println("Volumen:      " + volumen + " m^3");
    System.out.println("Beschriftung: " + tcObjekt.beschriftung());
  }
}

In unserer Testklasse InterfaceTest werden zuerst die beiden Objekte tischTisch und tcTisch erzeugt. Beide Objekte sind kompatibel zu dem abgeleiteten Interface TransportAndComparable.

In Zeile 14 und 17 vergleichen wir die beiden Objekte jeweils miteinander. Da beide Objekte das Comparable-Interface implementieren und sie jeweils in einer Objektvariable gespeichert sind, die kompatibel zu dem Typ Comparable ist, kann die Methode compareTo(Object obj) aufgerufen werden.

In Zeile 20 speichern wir das Objekt tischTisch in der Objektvariable tcObjekt vom Typ TransportAndComparable. Wir benutzen diese Variable als allgemeine Variable für Objekte, die kompatibel zu dem TransportAndComparable-Datentyp sind.

Im Folgenden geben wir die Transportdetails für beide Objekte aus. Wir arbeiten dabei in beiden Fällen mit der selben Objektvariable tcObjekt, da sie Objekte vom Typ Tisch aufnehmen kann. Würden auch andere Klassen das Interface TransportAndComparable implementieren, könnte unsere Objektvariable tcObjekt auch Objekte vom Typ der neuen Klassen aufnehmen.

Starten wir nun die Beispielanwendung. In der unteren Abbildung ist die Kommandozeilenausgabe des Programms dargestellt:

Ableiten von Interfaces in Java – Ausgabe der Beispielanwendung

Hier geht es zurück zum Kurs für Java Programmieranfänger.