This content originally appeared on HackerNoon and was authored by Maximiliano Contieri
When parent and child methods collide!
\
TL;DR: Avoid using private methods in parent classes with names that child classes can use.
Problems
- The least surprise principle violation
- Unexpected behavior and defects
- Hidden dependencies
- Limited extensibility
- Code ambiguity
- Open/Closed principle violation
- Misleading design
Solutions
- Avoid hierarchies
- Rename private methods
- Maintain clear naming
- Avoid overlapping names
- Avoid protected methods
- Subclassify for essential relations, not to reuse code
Context
When you use the same method name in parent and child classes, you create confusion.
A private method in the parent class cannot be overridden even if a public method with the same name exists in the child class.
This is a problem most static languages have in their design. This disconnect leads to bugs and makes your code hard to maintain.
Sample Code
Wrong
<?
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'
Right
<?
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
Detection
- [x] Semi-Automatic
You can detect this smell by looking for private methods in parent classes and checking if child classes define methods with the same name. You must also test parent methods calling private methods.
Tags
- Hierarchy
Level
- [x] Intermediate
Why the Bijection Is Important
Clear and predictable code should reflect the real-world hierarchy it models.
When you use private methods with overlapping names, you create a Bijection gap between the model and the implementation.
This gap confuses developers, increases defects, and violates clean code principles.
AI Generation
AI generators often create this smell when they generate boilerplate parent-child relationships.
They might not check access levels or consider inheritance implications.
AI Detection
AI tools can fix this smell with clear instructions.
You can ask the AI to check for overlapping method names and refactor hierarchies.
\ Try Them!
Remember: AI Assistants make lots of mistakes
| Without Proper Instructions | With Specific Instructions | |----|----| | ChatGPT | ChatGPT | | Claude | Claude | | Perplexity | Perplexity | | Copilot | Copilot | | Gemini | Gemini |
Conclusion
When designing parent and child classes, you should use methods that clearly define inheritance and accessibility.
Avoid private methods that overlap with child methods. This keeps your code readable, extensible, and aligned with clean code principles.
Languages like Python allow you to override parent methods regardless of their names, while Java strictly enforces access levels.
C# behaves similarly to Java. These differences mean you need to understand the specific rules of the language you are working with to avoid unexpected behavior.
Relations
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
\
:::warning Disclaimer: Code Smells are my opinion.
:::
:::info Credits: Photo by Matt Artz on Unsplash
:::
Inheritance is good, but you should never forget that it introduces tight coupling.
Robert C. Martin
https://hackernoon.com/400-thought-provoking-software-engineering-quotes?embedable=true
:::tip This article is part of the CodeSmell Series on HackerNoon.
:::
https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-i-xqz3evd?embedable=true
\
This content originally appeared on HackerNoon and was authored by Maximiliano Contieri
Maximiliano Contieri | Sciencx (2025-01-16T12:02:13+00:00) Code Smell 286 – Parent-Child Method Overlaps. Retrieved from https://www.scien.cx/2025/01/16/code-smell-286-parent-child-method-overlaps/
Please log in to upload a file.
There are no updates yet.
Click the Upload button above to add an update.