Vererbung Interface

[TaxiDriver]

interface I {
    public String doFoo();
}
class A implements I {
    public String doFoo() {
        System.out.println("A does foo");
    }
}
class B implements I {
    public String doFoo() {
        System.out.println("B does foo");
    }
}

I.doFoo();

Versteh ich nicht. Im Interface wird die Methode deklariert, aber in den Klassen steht das gleiche nochmal drin? Oder steht das alles im Interface drin? Wo würde ich etwas berechnen? Ein Beispiel mit Berechnung wäre gut, vllt versteh ich dann den Sinn.

Danke.

 

[thecain]

Das Interface ist eine "Bauanleitung", die Klasse welche das Interface implementiert beinhaltet die Logik.

I.doFoo() geht bestimmt nicht...

wenn dann

I myClass = new B();
myClass.doFoo();

aber viel abstraktere Beispiele als foo A, B, I kriegst du dann auch kaum hin.

 

[TaxiDriver]

public interface Vehicle {
    public void beschleunigung();
    public void bremse();
    public void handling();

}

public class Honda implements Vehicle{

    @Override
    public void beschleunigung() {
        System.out.println("Honda.beschleunigung");
    }

    @Override
    public void bremse() {
        System.out.println("Honda.bremse");
    }

    @Override
    public void handling() {
        System.out.println("Honda.handling");
    }

}

public class Driver {
    public static void main(String[] arg){
    Vehicle myVehicle = new Honda();
    myVehicle.beschleunigung();
    }
}

Es wird "Honda.beschleunigung" ausgegeben. Was bringt mir das jetzt?
Ich könnte jetzt statt sout. Methoden zum berechnen von beschleunigung, bremese,... schreiben? Wo genau ist dann der Vorteil? Warum nicht einfach 3 Methoden?

 

[Dompteur]

Ich glaube, um den Nutzen von Interfaces zu sehen, müsstest du noch eine weitere Klasse anlegen, die das Interface Vehicle implementiert. Nenne wie die neue Klasse einfach VW.

List<Vehicle> myList = new ArrayList<Vehicle>()
myList.add(new Honda());
myList.add(new VW());
...

Obwohl es nun keine Ableitungsbeziehung zwischen Honda und VW gibt, kannst du Objekte beider Klassen in einer Liste verwalten und alle Methoden des Interfaces auf diesen Objekten ausführen.

 

[Joose]

Einen Vorteil hat dir Dompteur schon geschrieben.

Der größere Vorteil von Interfaces ist die Entkoppelung von Code.
Beispiel:

public interface CarLoader {
   void addCar(Car c);
   void updateCar(Car c);
   void deleteCar(Car c);
   Car getCar(int id);
   List<Car> getCars();
}

public class FileCarLoader implements CarLoader {
   // speichert die Auto Daten in Dateien
   .....
}

public class SqlCarLoader implements CarLoader {
   // speichert die Auto Daten in einer Datenbank
   .....
}

public class BusinessLogic {
   CarLoader loader;
   
   public BusinessLogic(CarLoader loader) {
     this.loader = loader;
   }
   
   public void sell(Car c, Customer newOwner) {
     c.setCustomer(newOwner);
     loader.update(c);
   }
}

......
// Hier kannst du je nach Laune und Anforderung die entsprechende Implementierung übergeben.
new BusinessLogic(new FileCarLoader());
new BusinessLogic(new SqlCarLoader());
......

Wenn du gegen eine konkrete Klasse programmierst und du willst nun diese Klasse gegen eine andere Implementierung austauschen, musst du überall den Typ anpassen und wenn du die Methoden nicht gleich genannt hast auch diese anpassen.
Je nach Umfang der Verwendung kann es vorkommen das du viel Code ändern musst, was nicht notwendig wäre.
Verwendest du stattdessen Interfaces, dann reicht es meist an den Code an einer Stelle anzupassen.

Wichtige Anwendungsgebiete sind Unittest und die Trennung von Schichten!
Unittest: eine Datenbank oder ein File faken indem man einfach eine Liste deklariert mit ein paar fixen Autodaten.
Trennung von Schichten: Man soll jede Schichten (UI, BusinessLogic, Services, Datenschicht, ....) austauschen können ohne die anderen Schichten deswegen anpassen zu müssen.

 

[strußi]

so kannst du eine Methode schreiben, die verschiedene Objects als Parameter entgegennimmt, indem du Objects vom Typ des Interface entgegen nimmst. Wenn du ein spezielles Object z.b. Audi als Parameter erwartest, kann die Methode nur mit Objects vom Typ Audi etwas anfangen, wenn du aber Objects, die das Interface Vehicle implementieren entgegen nimmst, kannst deine Methode alle Autos die dieses Interface implementieren als Parameter entgegen nehmen ;-)