Puisque ce sujet n'est pas proche, je publierai cette réponse, j'espère que cela aidera quelqu'un à comprendre pourquoi java n'autorise pas l'héritage multiple.
Considérez la classe suivante:
public class Abc{
public void doSomething(){
}
}
Dans ce cas, la classe Abc ne prolonge rien non? Pas si vite, cette classe étend implicitement la classe Object, classe de base qui permet à tout de fonctionner en java. Tout est un objet.
Si vous essayez d'utiliser la classe ci - dessus , vous verrez que votre IDE vous permettent d'utiliser des méthodes telles que : equals(Object o), toString(), etc, mais vous ne l' avez pas déclaré ces méthodes, ils sont venus de la classe de baseObject
Tu pourrais essayer:
public class Abc extends String{
public void doSomething(){
}
}
C'est bien, car votre classe ne s'étendra pas implicitement Objectmais s'étendra Stringparce que vous l'avez dit. Considérez le changement suivant:
public class Abc{
public void doSomething(){
}
@Override
public String toString(){
return "hello";
}
}
Maintenant, votre classe retournera toujours "hello" si vous appelez toString ().
Imaginez maintenant la classe suivante:
public class Flyer{
public void makeFly(){
}
}
public class Bird extends Abc, Flyer{
public void doAnotherThing(){
}
}
Encore une fois la classe Flyerimplicite s'étend Object qui a la méthode toString(), n'importe quelle classe aura cette méthode puisqu'elles s'étendent toutes Objectindirectement, donc, si vous appelez à toString()partir de Bird, quel toString()Java devrait utiliser? De Abcou Flyer? Cela se produira avec n'importe quelle classe qui essaie d'étendre deux classes ou plus, pour éviter ce genre de "collision de méthodes", ils ont construit l'idée d' interface , en gros vous pourriez les considérer comme une classe abstraite qui n'étend pas Object indirectement . Comme ils sont abstraits, ils devront être implémentés par une classe, ce qui est un objet(vous ne pouvez pas instancier une interface seule, ils doivent être implémentés par une classe), donc tout continuera à fonctionner correctement.
Pour différer les classes des interfaces, le mot clé implements était réservé uniquement aux interfaces.
Vous pouvez implémenter n'importe quelle interface que vous aimez dans la même classe puisqu'elles n'étendent rien par défaut (mais vous pouvez créer une interface qui étend une autre interface, mais encore une fois, l'interface "père" n'étend pas Object "), donc une interface est juste une interface et ils ne souffriront pas de " colissions de signatures de méthodes ", s'ils le font, le compilateur vous lancera un avertissement et vous devrez juste changer la signature de la méthode pour la corriger (signature = nom de la méthode + paramètres + type de retour) .
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
}