Code Smell 286 - Parent-Child Method Overlaps

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

1. Avoid hierarchies
2. Rename private methods
3. Maintain clear naming
4. Avoid overlapping names
5. Avoid protected methods
6. 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

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

Inheritance is good, but you should never forget that it introduces tight coupling.

Robert C. Martin