Zweck von Interfaces immer noch nicht klar

[Java_Newb]

Hallo,

ich habe schon unter der FAQ-Übersicht das Thema "Interfaces" durchgelesen, aber bin nicht wirklich schlau daraus geworden.
Sorry also, wenn ich die Frage hier nochmal stelle:

Wenn ich zwei Klassen A und B habe, ist es ja nicht möglich, dass Klasse C von beiden Klassen A und B erbt (Mehrfachvererbung nicht möglich).
Daher erbt Klasse C z. B. von Klasse A und implementiert das Interface D. Was bringt es mir aber eine abstrakte Methode zu implementieren, wenn ich die Methode sowieso in der Klasse C definieren muss, sobald ich das Schlüsselwort "implements" benutze?
Ich werde echt nicht schlau daraus.

Ich hoffe, einer kann es mir anschaulich erklären.

 

[httpdigest]

Warum möchte man generell Interfaces haben? => Abstraktion!
In objektorientierten Sprachen wie Java wird Abstraktion durch Subtyping realisiert.
Das heißt, du kannst von einer konkreten Klasse abstrahieren und dem Client (Nutzer deiner Klasse) einfach eine abstraktere "Sicht" auf deine Klasse über ein implementiertes Interface geben.
Bestes Beispiel ist hier z.B. das Java Collections API mit java.util.List und möglichen Implementierungen wie etwa java.util.ArrayList oder java.util.LinkedList, je nachdem, welche Laufzeitkomplexität du für verwendete Operationen benötigst.
Du abstrahierst mit einem Interface also eine konkrete Implementierung weg.
Anderes Beispiel: java.lang.Comparable. Dieses Interface definiert nur einen Kontrakt/Vertrag, was die Operation compareTo im Allgemeinen tun soll. Jetzt gibt es hunderttausende mögliche Implementierungen, um jeweils konkrete Klassen miteinander zu vergleichen, die eben durch konkrete Klassen, die Comparable implementieren, festgelegt wird.
Ein Algorithmus, der z.B. Sortierung implementiert, muss nun nicht mehr für jede zu sortierende Klasse extra geschrieben werden, sondern muss nur durch java.lang.Comparable bekannt gegeben werden, wie zwei Instanzen einer Klasse zu vergleichen sind.

 

[M.L.]

Der erste Satz im Posting von https://www.java-forum.org/thema/wi...vernuenftige-klassen-ein.185926/#post-1197005 bringt es zusätzlich auf den Punkt.

 

[White_Fox]

Ein kleines Beispiel zur Verdeutlichung:

Du hast einen Vererbungsbaum Landfahrzeuge:

public class LandVehicle{
 
    public void drive(){
        //...
    }
}

//Von dieser Klasse werden jetzt weitere Klassen abgeleitet:

public class Truck extends LandVehicle{}

public class Car extends LandVehicle{}

public class Tank extends LandVehicle{}

Und du hast noch einen ganz anderen Vererbungsbaum, nämlich Fluggeräte:

public class Aircraft{
 
    public void fly(){
        //...
    }
}

//Von dieser Klasse werden jetzt weitere Klassen abgeleitet:

public class Helicopter extends Aircraft{}

public class Rocket extends Aircraft{}

public class Plane extends Aircraft{}

So weit, so gut, das kennst du alles.
Aber: jetzt möchtest du auch einen Amphibienpanzer und ein Wasserflugzeug haben:

public class AmphibiousTank extends LandVehicle{
    //...
}

public class SeaPlane extends Aircraft{
    //...
}

Jetzt willst du auch mit den beiden neuen Klassen ja auch irgendwie arbeiten. Und du willst ganz sicher nicht für jede der beiden Klassen getrennte Methoden schreiben oder sonstwie ständig zwischen den Klassen unterscheiden. Auch wenn ein Fluggerät und ein Landfahrzeug völlig verschiedene Dinge sind haben sie etwas gemeinsam: Sie können (auch) schwimmen, und das möchtest du gefälligst abbilden, damit du diese Geräte auch auf einem Wasserparkplatz abstellen kannst.

Wir erstellen einfach mal eines für alles, was schwimmen kann:

public Interface Swimmable{
    public void swimm(double destX, double destY);    //XY-Koordinaten
}

Unsere beiden Klassen Wasserflugzeug und Amphibienpanzer müssen dieses jetzt implementieren:

public class AmphibiousTank extends LandVehicle implements Swimmable{
    public void swimm(double destX, double destY){
        //...Implementierung...
    }
}

public class SeaPlane extends Aircraft implements Swimmable{
    public void swimm(double destX, double destY){
        //...Implementierung...
    }
}

Und nun werden Interfaces ganz großartig, denn jetzt kannst du einfach Folgendes machen:

public class Harbour{
    //...
 
    public void bringVehicleToParkposition(Swimmable vehicle){
        vehicle.swimm(2, 3);
    }
 
    //...
}

Oder für andere Beispiele: Schaue dir mal verschiedene Entwurfsmuster an. Die direkte Übersetzung Schnittstelle kannst du eigentlich immer wörtlich nehmen.

Das Observer Design Pattern (Beobachter Entwurfsmuster))

Eine ausführliche Analyse des Observer Design Pattern (Beobachter Entwurfsmuster) mit Einführung und Diskussion.

www.philipphauer.de

Das Strategy Design Pattern (Strategie Entwurfsmuster)

Eine ausführliche Analyse des Strategy Design Pattern (Strategie Entwurfsmuster) mit Einführung und Diskussion.

www.philipphauer.de

Oder mein Lieblingsentwurfsmuster:

Das Decorator Design Pattern (Dekorierer Entwurfsmuster)

Eine ausführliche Analyse des Decorator Design Pattern (Dekorierer Entwurfsmuster) mit Einführung und Diskussion.

www.philipphauer.de