Dato che questo argomento non è vicino, pubblicherò questa risposta, spero che questo aiuti qualcuno a capire perché java non consente l'ereditarietà multipla.
Considera la seguente classe:
public class Abc{
public void doSomething(){
}
}
In questo caso la classe Abc non estende nulla di giusto? Non così in fretta, questa classe implicita estende la classe Object, classe base che consente a tutto di funzionare in Java. Tutto è un oggetto.
Se si tenta di utilizzare la classe di cui sopra vedrete che il vostro IDE consentono di utilizzare metodi come: equals(Object o), toString(), ecc, ma non ha dichiarato i metodi, sono venuti dalla classe baseObject
Puoi provare:
public class Abc extends String{
public void doSomething(){
}
}
Questo va bene, perché la tua classe non si estende implicitamente Objectma si estende Stringperché l'hai detto. Considera la seguente modifica:
public class Abc{
public void doSomething(){
}
@Override
public String toString(){
return "hello";
}
}
Ora la tua classe restituirà sempre "ciao" se chiami toString ().
Ora immagina la seguente classe:
public class Flyer{
public void makeFly(){
}
}
public class Bird extends Abc, Flyer{
public void doAnotherThing(){
}
}
Ancora una volta la classe Flyerimplicita estende l'oggetto che ha il metodo toString(), qualsiasi classe avrà questo metodo poiché si estende tutti Objectindirettamente, quindi, se chiami toString()da Bird, quale toString()Java dovrebbe usare? Da Abco Flyer? Questo accadrà con qualsiasi classe che tenti di estendere due o più classi, per evitare questo tipo di "collisione del metodo" hanno costruito l'idea di interfaccia , in pratica potresti pensarle come una classe astratta che non estende indirettamente l'oggetto . Poiché sono astratti , dovranno essere implementati da una classe, che è un oggetto (non è possibile installare un'interfaccia da sola, devono essere implementati da una classe), quindi tutto continuerà a funzionare correttamente.
Per differenziare le classi dalle interfacce, la parola chiave implementa era riservata solo alle interfacce.
Potresti implementare qualsiasi interfaccia che ti piace nella stessa classe poiché non estende nulla per impostazione predefinita (ma potresti creare un'interfaccia che estende un'altra interfaccia, ma di nuovo, l'interfaccia "padre" non estende l'oggetto "), quindi un'interfaccia è solo un'interfaccia e non soffriranno di " collisioni della firma dei metodi ", se lo fanno il compilatore ti lancerà un avvertimento e dovrai solo cambiare la firma del metodo per risolverlo (firma = nome metodo + parametri + tipo restituito) .
public interface Flyer{
public void makeFly(); // <- method without implementation
}
public class Bird extends Abc implements Flyer{
public void doAnotherThing(){
}
@Override
public void makeFly(){ // <- implementation of Flyer interface
}
// Flyer does not have toString() method or any method from class Object,
// no method signature collision will happen here
}