Comment Java résout-il l'ambiguïté lors du remplacement de méthodes dans plusieurs interfaces ?

Surmonter 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 qui se chevauchent n'aura qu'une seule implémentation efficace . Le compilateur ne fait pas de distinction entre les méthodes en fonction de leur origine d'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, 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 Test, la classe remplace effectivement la méthode f() des deux interfaces, même si une seule annotation @Override est présente.

En effet, les règles d'héritage de Java dictent que les méthodes avec des signatures identiques sont prises en compte. "équivalent à un remplacement." En conséquence, le compilateur choisit la première méthode prioritaire qu'il rencontre, quelle que soit l'origine de son interface.

De plus, des incompatibilités peuvent survenir si les méthodes en conflit ont des types de retour différents. Dans de tels cas, le compilateur signalera 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, Gift.present() et Guest.present() ont des types de retour incompatibles (void vs boolean). Par conséquent, Presentable ne peut pas implémenter les deux interfaces car elles violent les règles de substitution.

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!