Override l'ambiguïté avec plusieurs interfaces

Dans le domaine de la programmation orientée objet, les classes peuvent implémenter plusieurs interfaces. Cependant, lorsque ces interfaces possèdent des méthodes avec des signatures identiques, une question se pose: comment le compilateur résout-il quelle méthode d'interface est remplacée?

En Java, une classe implémentant plusieurs interfaces avec de telles méthodes de chevauchement n'aura qu'une seule implémentation efficace. Le compilateur ne fait pas de distinction entre les méthodes basées sur l'origine de leur interface.

pour comprendre ce concept, considérons l'exemple suivant:

interface A {
  int f();
}

interface B {
  int f();
}

class Test implements A, B {   
  @Override
  public int f() {  
    return 0;
  }
}   

Dans ce scénario, le test implémente à la fois A et B, et les deux interfaces définissent une méthode nommée f () avec la même signature. En remplaçant cette méthode dans le test, la classe remplace efficacement la méthode f () à partir des deux interfaces, même si une seule annotation @Override est présente.

C'est parce que les règles d'hérédité de Java dictent que les méthodes avec des signatures identiques sont considérées comme «l'équivalent de versement». En conséquence, le compilateur choisit la première méthode primordiale qu'il rencontre, quelle que soit l'origine de son interface.

En outre, des incompatibilités peuvent survenir si les méthodes conflictuelles ont des types de retour différents. Dans de tels cas, le compilateur rapportera une erreur, car il n'est pas possible d'avoir deux méthodes avec la même signature mais des types de retour différents dans la même classe.

pour illustrer ce point, modifions l'exemple comme suit:

interface Gift {
  void present();
}

interface Guest {
  boolean present();
}

class Presentable implements Gift, Guest {
  @Override
  public void present() {
    System.out.println("Present as a gift!");
  }
}

Ici, done.present () et invité.present () ont des types de retour incompatibles (void vs booléen). En conséquence, le présentable ne peut pas implémenter les deux interfaces car ils violent les règles de remplacement.

En conclusion, lorsqu'une classe implémente plusieurs interfaces avec des méthodes équivalentes à l'Override, le compilateur reconnaît qu'il n'y a qu'une seule méthode à implémenter, et l'annotation @Override sur la méthode de remplacement s'applique à toutes les interfaces. Cependant, les incompatibilités entre les signatures de méthode conduiront à des erreurs de compilation.