Ullrich: Die Seite wurde neu angelegt: „Category:Java Java kennt keine Mehrfachvererbung, eine Klasse kann immer nur von ''einer'' Klasse abgeleitet werden. Das alternative Konzept sind Interface…“

2021-10-05T16:34:07Z

Die Seite wurde neu angelegt: „Category:Java Java kennt keine Mehrfachvererbung, eine Klasse kann immer nur von ''einer'' Klasse abgeleitet werden. Das alternative Konzept sind Interface…“

Neue Seite

[[Category:Java]]
Java kennt keine Mehrfachvererbung, eine Klasse kann immer nur von ''einer'' Klasse abgeleitet werden.
Das alternative Konzept sind Interfaces: Jede Klasse kann – zusätzlich zu ihrer Superklasse – beliebig
viele Interfaces implementieren. Auf diese Weise kann ein Objekt einer Klasse – je nach Kontext – unterschiedliche
Schnittstellen haben und unterschiedlich behandelt werden. Wie aber stellt man es an, ein Objekt gleichzeitig
unter mehreren Blickwinkeln zu betrachten? Zur Motivation und zur Erklärung dieser zunächst etwas akademisch
anmutenden Frage diene uns ein einfaches Beispiel. Angenommen, wir haben zunächst ein Interface das das Volumen
von beliebigen Behältern beschreibt:
{{java|code=
interface Behaelter {
double volumen();
}
}}
Dazu haben wir ein Interface, über das wir Informationen zum Inhalt abfragen können – zum Beispiel das spezifische Gewicht:
{{java|code=
interface Inhalt {
double dichte();
}
}}
Mit diesen beiden Interfaces können wir nun – zum Beispiel um ein Schiff zu beladen – verschiedene Behälter
definieren, die unterschiedliche Dinge enthalten können; über die fehlenden Maßeinheiten sehen wir mal großzügig
hinweg. Von der weiteren Natur dieser Behälter sind unsere Interfaces völlig unabhängig:
{{java|code=
public class Zuckersack implements Behaelter, Inhalt {
@Override
public double volumen() {
return 100;
}
@Override
public double dichte() {
return 1.6;
}
}
}}
Die Aufgabe besteht nun darin, eine Rechner-Klasse zu bauen die das Gewicht gefüllter Gefäße berechnet. Eine
ebenso billige wie häßliche Methode sähe etwa so aus:
{{java|code=
public double gewicht(Object dings) {
if (dings instanceof Behaelter && dings instanceof Inhalt) {
return ((Behaelter) dings).volumen() * ((Inhalt) dings).dichte();
}
throw new IllegalArgumentException();
}
}}
Abgesehen von der mangelnden Übersichtlichkeit fliegt uns das Konstrukt erst bei falscher Anwendung zur
Laufzeit um die Ohren. Besser wäre es, wenn wir schon zur Compile-Zeit erführen, ob ein Objekt als Methoden-
Argument geeignet ist oder nicht. Dank Javas statischer Typisierung sollte das eigentlich kein Problem sein und
seit Java 1.5 kann man das mit Generics auch sehr viel hübscher hinbekommen.
Eine generische Methoden-Signatur kann in Java zum Beispiel so aussehen:
{{java|code=public <T> double foo(T dings);}}
Was die Methode tut, sei erstmal egal, wir sehen uns zunächst nur die Signatur an:

{{java|foo}} sei eine Methode, die einen Parameter des generischen Typs {{java|T}} übernimmt und als Ergebnis einen
double-Wert liefert. Der parametrisierte Typ {{java|T}} wird dazu in spitzen Klammern vor dem Rückgabe-Wert angegeben.
Er kann dann als Typ in der Parameterliste und als Rückgabe-Typ verwendet werden. Im obigen Beispiel brauchen wir ihn
nur für den Parameter {{java|dings}}. Da im Beispiel keine Einschränkungen gemacht werden, kann {{java|T}} beim Aufruf
der Methode durch beliebige Klasse oder ein beliebiges Interface ersetzt werden. Der Aufruf
{{java|code=foo(Integer.valueOf(1));}}
ist ebenso zulässig wie der Aufruf
{{java|code=foo("1");}}
Um mit dem Parameter etwas Sinnvolles anstellen zu können, müssen wir ihn etwas einschränken. Zunächst sollen
nur Klassen erlaubt werden, die das Interface {{java|Behaelter}} implementieren:
{{java|code=
public <T extends Behaelter> double wasDrinIst(T dings) {
return dings.volumen();
}
}}
Der Parameter {{java|dings}} muß damit ein Objekt einer Klasse sein, die das Interface {{java|Behaelter}} implementiert und
daher können wir darauf die Methode {{java|volumen()}} aufrufen. Tatsächlich ist die generische Methoden-Deklaration
äquivalent zu dieser klassischen Variante:
{{java|code=
public double wasDrinIst(Behaelter dings) {
return dings.volumen();
}
}}
Und jetzt kommt der Trick: In der klassischen Variante ''ohne'' Generics kann der Parameter {{java|dings}} nur einen einzigen
Typ haben, im Beispiel ist das das Interface {{java|Behaelter}}. Im Gegensatz dazu kann der generische Typ {{java|T}} mehrere
Typen haben, die durch den {{java|&}}-Operator verknüpft werden. Die endgültige Methode zur Berechnung des Gewichts
sieht dann so aus:
{{java|code=
public <T extends Behaelter & Inhalt> double gewicht(T dings) {
return dings.volumen() * dings.dichte();
}
}}
{{java|T}} ist nun ein Typ, der die Interfaces {{java|Behaelter}} ''und'' {{java|Inhalt}} implementiert.
Damit können wir die Methode {{java|volumen()}} aus dem Interface {{java|Behaelter}} und die Methode
{{java|dichte()}} aus dem Interface {{java|Inhalt}} auf das Objekt {{java|dings}} anwenden. Tatsächlich
kann man beliebig viele Typen angeben, die mit den {{java|&}}-Operator verknüpft werden. Darunter darf
auch ''eine'' Klasse sein, diese muß dann aber an erster Stelle stehen. Korrekt – wenn auch redundant – wäre
folgende Definition:
{{java|code=
public <T extends Object & Behaelter & Inhalt> double gewicht(T dings) {
return dings.volumen() * dings.dichte();
}
}}
Die Anwendung der Interface-Kombination ist nicht auf Methoden beschränkt. Man kann sie auch zur
parametrisierten Definition generischer Klassen verwenden:
{{java|code=
public class Ladung <T extends Behaelter & Inhalt> {
List<T> fracht = new ArrayList<>();
}
}}
Den Code zu den aufgeführten Beispielen giebt's auf [https://github.com/mletkin/JavaSamples/tree/master/src/main/java/org/ully/samples/generics/inheritance Git-Hub].

Generics und Klassen mit vielen Gesichtern - Versionsgeschichte

Ullrich: Die Seite wurde neu angelegt: „Category:Java Java kennt keine Mehrfachvererbung, eine Klasse kann immer nur von ''einer'' Klasse abgeleitet werden. Das alternative Konzept sind Interface…“