Code Odeur 286 – Chevauchement des méthodes parent-enfant

Quand les méthodes parent et enfant entrent en collision !

TL;DR : évitez d’utiliser des méthodes privées dans les classes parentes avec des noms que les classes enfants peuvent utiliser.

Problèmes

• La violation du principe de moindre surprise
• Comportement et défauts inattendus
• Dépendances cachées
• Extensibilité limitée
• Ambiguïté du code
• Violation du principe ouvert/fermé
• Conception trompeuse

Solutions

1. Éviter les hiérarchies
2. Renommer les méthodes privées
3. Maintenir une dénomination claire
4. Évitez les noms qui se chevauchent
5. Évitez les méthodes protégées
6. Sous-classer pour les relations essentielles , ne pas réutiliser le code

Contexte

Lorsque vous utilisez le même nom de méthode dans les classes parent et enfant, vous créez de la confusion.

Une méthode privée dans la classe parent ne peut pas être remplacée même si une méthode publique portant le même nom existe dans la classe enfant.

Il s'agit d'un problème que rencontrent la plupart des langages statiques dans leur conception. Cette déconnexion entraîne des bugs et rend votre code difficile à maintenir.

Exemple de code

Faux

 <? class ParentClass { private function greet() { // This method is private return "Hello from ParentClass"; } public function callGreet() { return $this->greet(); } } class ChildClass extends ParentClass { public function greet() { // Overriding a concrete method is a code smell // Compilers SHOULD warn you return "Hello from ChildClass"; } } $child = new ChildClass(); echo $child->callGreet(); // When callGreet() is invoked on the $child object, // it executes the following: // It calls $this->greet(), // which refers to the greet() method of ParentClass // because the original method is private // and cannot be overridden or accessed from ChildClass. // The unexpected output is 'Hello from ParentClass'

Droite

 <? class ParentClass { protected function greet() { // notice the 'protected qualifier' return "Hello from ParentClass"; } public function callGreet() { return $this->greet(); } } class ChildClass extends ParentClass { public function greet() { return "Hello from ChildClass"; } } $child = new ChildClass(); echo $child->callGreet(); // The output is "Hello from ChildClass" // This is the standard (and wrong) solution // Also fixed by most AIs

 <? abstract class ParentClass { // Declare greet() as an abstract method // Following the template-method design pattern abstract protected function greet(); public function callGreet() { return $this->greet(); } } class ChildClass extends ParentClass { protected function greet() { return "Hello from ChildClass"; } } class OtherChild extends ParentClass { protected function greet() { return "Hello from OtherChild"; } } $child = new ChildClass(); echo $child->callGreet(); // Output: Hello from ChildClass $otherChild = new OtherChild(); echo $otherChild->callGreet(); // Output: Hello from OtherChild

Détection

• [x] Semi-automatique

Vous pouvez détecter cette odeur en recherchant des méthodes privées dans les classes parentes et en vérifiant si les classes enfants définissent des méthodes portant le même nom. Vous devez également tester les méthodes parentes appelant des méthodes privées.

Mots clés

• Hiérarchie

Niveau

• [x] Intermédiaire

Pourquoi la bijection est importante

Un code clair et prévisible doit refléter la hiérarchie du monde réel qu’il modélise.

Lorsque vous utilisez des méthodes privées avec des noms qui se chevauchent, vous créez un écart de bijection entre le modèle et l'implémentation.

Cet écart déroute les développeurs, augmente les défauts et viole les principes du code propre.

Génération IA

Les générateurs d’IA créent souvent cette odeur lorsqu’ils génèrent des relations parent-enfant standard.

Il se peut qu’ils ne vérifient pas les niveaux d’accès ou ne prennent pas en compte les implications en matière d’héritage.

Détection de l'IA

Les outils d’IA peuvent corriger cette odeur avec des instructions claires.

Vous pouvez demander à l'IA de vérifier les noms de méthodes qui se chevauchent et de refactoriser les hiérarchies.

Essayez-les !

N'oubliez pas : les assistants IA font beaucoup d'erreurs

Conclusion

Lors de la conception des classes parent et enfant, vous devez utiliser des méthodes qui définissent clairement l'héritage et l'accessibilité.

Évitez les méthodes privées qui chevauchent les méthodes enfants. Cela permet de garder votre code lisible, extensible et conforme aux principes du code propre.

Des langages comme Python vous permettent de remplacer les méthodes parentes quel que soit leur nom, tandis que Java applique strictement les niveaux d'accès.

Le langage C# se comporte de manière similaire à Java . Ces différences impliquent que vous devez comprendre les règles spécifiques du langage avec lequel vous travaillez pour éviter tout comportement inattendu.

Rapports

https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxviii

https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xii

https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-iii-t7h3zkv

https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxv

https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-viii-8mn3352

L’héritage est une bonne chose, mais il ne faut jamais oublier qu’il introduit un couplage étroit.

Robert C. Martin