Comment substituer la méthode pour appeler la méthode de la superclasse de la superclasse?

Question

Une partie de moi pense que cela ne devrait pas être possible (même si c'est le cas), mais je demanderai quand même.

Compte tenu de la hiérarchie de classe suivante (Grandparent et Parent sont d'une 3ème partie et donc pas sous mon contrôle), comment pourrais-je passer outre myMethod() dans Child telle qu'elle contourne la mise en œuvre surchargée dans Parent et invoque celui Grandparent?

class Grandparent { 
    public void myMethod() { 
     // do stuff 
    } 
} 

class Parent extends Grandparent { 
    @Override public void myMethod() { 
     super.myMethod(); 
     // do something else 
    } 
} 

class Child extends Parent { 
    @Override public void myMethod() { 
     // ??? I want to *only* do what Grandparent did here 
    } 
} 

Pretend que la classe Parent offre beaucoup d'autres comportements utiles et est un élément crucial de la hiérarchie de Child (autrement dit, je ne suis pas à la recherche de « faire Child une sous-classe de Grandparent ».

Answer 1

L'idée derrière héritage est que chaque classe définit leurs méthodes dont ils ont besoin, de sorte que vous n'avez pas besoin d'inspecter un code.

Il semble que vous sous-classez ici juste pour réutiliser le code, et ce n'est pas l'idée de sous-classer. Peut-être que vous devriez avoir un membre auxiliaire pour effectuer certaines des tâches dont vous avez besoin, au lieu de sous-classer, et que les classes «Enfant» et «Parent» étendent «Grand-parent».

La question principale que vous devez vous poser est: «L'enfant est-il vraiment un descendant de parent, de grand-parent ou de neiter? En d'autres termes, pour chaque instance de Child, puis-je dire que c'est un parent?

Si la réponse est non, alors vous êtes à tort le sous-classement: l'héritage est censé vouloir dire quelque chose, non seulement le code de réutilisation (c.-à-Ford EST AUSSI une voiture, non seulement « Ford » utilise Méthodes "Car").

Answer 2

pas possible.

Je voudrais créer une méthode d'assistance final dans un grand-parent à la place. Et cette méthode (qui est surchargée) appeler aide.

class Grandparent { 
    public final void myHelperMethod() { 
     // do stuff 
    } 
    public void myMethod() { 
     myHelperMethod(); 
    } 
} 

class Parent extends Grandparent { 
    @Override public void myMethod() { 
     super.myMethod(); 
     // do something else 
    } 
} 

class Child extends Parent { 
    @Override public void myMethod() { 
     // ??? I want to *only* do what Grandparent did here 
     myHelperMethod(); 
    } 
} 

Answer 3

Contrôlez-vous la classe Parent?

Si oui, pourriez-vous ajouter une méthode (myNewMethod) au Parent qui appelle myMethod sur Grandparent, et appelle myNewMethod de Child?

(je ne suis pas une personne de Java, donc je ne sais pas si vous ne pouvez appeler une méthode dans une superclasse d'une substitution de cette méthode dans une sous-classe)

class Grandparent { 
    public void myMethod() { 
     myHelperMethod(); 
    } 
} 

class Parent extends Grandparent { 
    @Override public void myMethod() { 
     super.myMethod(); 
     // do something else 
    } 
    public final void myNewMethod() { 
     super.myMethod(); 
    } 
} 

class Child extends Parent { 
    @Override public void myMethod() { 
     // ??? I want to *only* do what Grandparent did here 
     myNewMethod(); 
    } 
} 

Answer 4

En supposant que je ne pouvais pas toucher le code parent ou grand-parent et en supposant que je ne suis pas, comme suggéré Seb (et que Steve a apparemment accepté) l'héritage abusant simplement tout:

Je créerais local exemple d'un objet Grand-père (ou d'une classe locale qui étend son grand-père, s'il est abstrait) et accède directement à son interprétation de myMethod(). Bien sûr, en fonction de la quantité d'informations d'état que myMethod() est supposé lire et/ou manipuler, la quantité de travail impliquée peut être quelque chose de «facile» à «insupportable».

C'est une solution moche, et, en fonction de la quantité d'informations d'état est accessible, pourrait être fragile comme l'enfer. Mais si Grand-père est stable de manière fiable et/ou myMethod() est assez autonome, cela pourrait fonctionner. Le diable est dans les détails, comme toujours.

Je suis tout à fait d'accord avec Seb que c'est une réutilisation, pas d'héritage. Mais salut. La réutilisation est souvent une bonne chose.