Impossible d'ouvrir l'implémentation pour la méthode ajoutée à l'interface à partir de la classe de base dans Eclipse

1. Quand vous le faites

ctrl + survol de la souris

, eclipse vous offre 2 options:

a. Déclaration ouverte.

b. Implémentation ouverte.

Vous devez sélectionner la deuxième option.

2. Je préférerais utiliser

'ctrl + T'

pour voir la hiérarchie complète de mise en œuvre.

J'espère que cela aide.

GeneralServiceImpl.doB () n'est pas une implémentation de MyService.doB() mais utilisé dans MyServiceImpl pour implémenter MyService.doB () . Par conséquent, il serait faux d'afficher GeneralServiceImpl.doB () comme implémentation ou définition de MyService.doB () .

Dans l'exemple suivant, annoter FooImpl avec @Override conduit à une erreur de compilation. Selon la Spécification du langage Java 9.6.4.4. cela signifie que FooImpl.foo () n'implémente ni ne définit API.foo():

class MyClass extends FooImpl implements API {
    @Override // <- correct
    public void bar() {};
}

interface API {
    void foo();
    void bar();
}

class FooImpl {
    // @Override <- compile error
    public void foo() {}
}

S'il vous plaît voir ce n'est pas un bug.

Permet de comprendre (j'ai fait une représentation picturale pour mieux comprendre):

Il est clair que la classe GeneralServiceImpl remplace la fonction doB () d'implémentation de l'interface GeneralService ainsi que MyServiceImpl implémente la fonction doC () de son interface d'implémentation MyService.

De plus, il existe une relation d'héritage entre MyServiceImpl et GeneralServiceImpl -> MyServiceImpl étend GeneralServiceImpl , donc MyServiceImpl a doB ( ) {} .

Nous devons maintenant comprendre ici que les IDE, la complétion et le compilateur utilisent la vue statique.

Si vous voulez connaître la vue d’exécution, alors on doit nous Le mode de débogage.

Donc, si nous voyons la façon dont vos classes et votre interface sont conçues, il n'y a pas de relation directe entre MyService et GeneralServiceImpl code >, donc eclipse n'est pas au courant de son implémentation runtime et ne met donc pas en évidence la même chose.

Au contraire, cette ligne pointillée dans le diagramme représente relation d'exécution et donc implémentation de la fonction void doB (); .

Ajout d'informations sur la base de @howlger comment :

Pour une Interface implémentant la classe , il faut remplacer toutes les fonctions déclarées (à moins que abstract ). et en tant qu'EDI Eclipse lors de la recherche d'une implémentation d'une fonction depuis Interface , il ne recherche que l'implémentation directe dans les classes d'implémentation. (comme pour doC () cela fonctionne). [vue statique / compilateur]

Maintenant, imaginez entre MyServiceImpl et GeneralServiceImpl nous avons une autre classe SubGeneralServiceImpl qui aussi remplace doB () comme

public class SubGeneralServiceImpl extends GeneralServiceImpl {
    public void doB() {
            //
        }
    }

et maintenant MyServiceImpl étend SubGeneralServiceImpl et SubGeneralServiceImpl étend encore GeneralServiceImpl.

Donc, même maintenant, MyServiceImpl a doB () mais maintenant l'accès à l'implémentation 2 doB () , qui peut être vu:

donc en vue statique (compilateur) c'est tout à fait correct dans la mesure où MyServiceImpl remplace doB () & doC () ... cependant Eclipse en tant qu'EDI ne sait pas quelle implémentation va être utilisée runtime, donc pas en mesure de vous donner l'implémentation de doB () lors de la tentative d'obtention de l'interface MyService .

J'espère que cela vous aidera.