Titel | Inhalt | Suchen | Index | DOC | Handbuch der Java-Programmierung, 3. Auflage
<< | < | > | >> | API | Kapitel 9 - OOP III: Interfaces

## 9.3 Mehrfachimplementierung und Vererbung

- 9.3 Mehrfachimplementierung und Vererbung
  - 9.3.1 Mehrfachimplementierung
  - 9.3.2 Vererbung von Interfaces
  - 9.3.3 Ableiten von Interfaces

### 9.3.1 Mehrfachimplementierung

Es ist durchaus möglich (und gebräuchlich), daß eine Klasse mehrere Interfaces implementiert. Sie muß dann zu jedem Interface alle darin definierten Methoden implementieren. Mit jedem implementierten Interface wird sie zu dem dadurch definierten Datentyp kompatibel. Eine Klasse, die n Interfaces implementiert, ist demnach zu n + 1 Datentypen (plus ihren jeweiligen Oberklassen) kompatibel:

- Der Vaterklasse, aus der sie abgeleitet wurde (bzw. der Klasse `Object`, falls keine `extends`-Klausel vorhanden war).
- Den n Interfaces, die sie implementiert.

Wir könnten beispielsweise die in Listing 9.2 definierte Klasse `Auto2` erweitern und sie die Interfaces `Groesse` und `Comparable` implementieren lassen:

    001 /* Auto3.java */
    002
    003 public class Auto3
    004 implements Groesse, Comparable
    005 {
    006   public String name;
    007   public int    erstzulassung;
    008   public int    leistung;
    009   public int    laenge;
    010   public int    hoehe;
    011   public int    breite;
    012
    013   public int laenge()
    014   {
    015     return this.laenge;
    016   }
    017
    018   public int hoehe()
    019   {
    020     return this.hoehe;
    021   }
    022
    023   public int breite()
    024   {
    025     return this.breite;
    026   }
    027
    028   public int compareTo(Object o)
    029   {
    030     int ret = 0;
    031     if (leistung < ((Auto3)o).leistung) {
    032       ret = -1;
    033     } else if (leistung > ((Auto3)o).leistung) {
    034       ret = 1;
    035     }
    036     return ret;
    037   }
    038 }
| Auto3.java

Listing 9.8: Implementierung mehrerer Interfaces

Nun sind Objekte dieses Typs sowohl zu `Groesse` als auch zu `Comparable` kompatibel (Hinweis: die Sortierung basiert in diesem Fall nicht auf der Größe des Autos, sondern auf seiner Leistung).

### 9.3.2 Vererbung von Interfaces

Die Implementierung hätte noch etwas vereinfacht werden können, wenn wir uns zu Nutze gemacht hätten, daß eine Klasse die Interfaces seiner Basisklasse erbt:

    001 /* Auto4.java */
    002
    003 public class Auto4
    004 extends Auto2
    005 implements Comparable
    006 {
    007   public int compareTo(Object o)
    008   {
    009     int ret = 0;
    010     if (leistung < ((Auto4)o).leistung) {
    011       ret = -1;
    012     } else if (leistung > ((Auto4)o).leistung) {
    013       ret = 1;
    014     }
    015     return ret;
    016   }
    017 }
| Auto4.java

Listing 9.9: Erben von Interfaces

`Auto4` erbt von `Auto2` nicht nur die Implementierung, sondern auch die Klausel `implements Groesse` und erweitert sie um die Implementierung von `Comparable`. Damit ist `Auto4` gleichwertig zu `Auto3`.

### 9.3.3 Ableiten von Interfaces

Auch Interfaces selbst können abgeleitet werden. Ähnlich einer Klasse erbt das abgeleitete Interface alle Methodendefinitionen des Basis-Interfaces. Die implementierende Klasse muß also auch alle Methoden von allen übergeordneten Interfaces implementieren:

    001 /* Listing0910.java */
    002
    003 interface EinDimensional
    004 {
    005   public int laenge();
    006 }
    007
    008 interface ZweiDimensional
    009 extends EinDimensional
    010 {
    011   public int breite();
    012 }
    013
    014 interface DreiDimensional
    015 extends ZweiDimensional
    016 {
    017   public int hoehe();
    018 }
    019
    020 interface VierDimensional
    021 extends DreiDimensional
    022 {
    023   public int lebensdauer();
    024 }
    025
    026 public class Listing0910
    027 implements VierDimensional
    028 {
    029   public int laenge() { return 0; }
    030   public int breite() { return 0; }
    031   public int hoehe() { return 0; }
    032   public int lebensdauer() { return 0; }
    033 }
| Listing0910.java

Listing 9.10: Ableiten von Interfaces

Titel | Inhalt | Suchen | Index | DOC | Handbuch der Java-Programmierung, 3. Auflage, Addison Wesley, Version 3.0
<< | < | > | >> | API | © 1998-2002 Guido Krüger, http://www.javabuch.de