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 Disclaimer: Code Smells are my opinion. 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 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 When parent and child methods collide! TL;DR: Avoid using private methods in parent classes with names that child classes can use. 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 The least surprise principle violation Unexpected behavior and defects defects Hidden dependencies Limited extensibility Code ambiguity Open/Closed principle violation Misleading design 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 Avoid hierarchies hierarchies Rename private methods Maintain clear naming Avoid overlapping names Avoid protected methods protected methods Subclassify for essential relations , not to reuse code essential relations 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' <?

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 <?

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 <?

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 [x] Semi-Automatic [x] 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 Hierarchy Level [x]Intermediate [x] Intermediate [x] Why the Bijection Is Important Clear and predictable code should reflect the real-world hierarchy it models. real-world When you use private methods with overlapping names, you create a Bijection gap between the model and the implementation. Bijection 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! 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 Without Proper Instructions

With Specific Instructions ChatGPT

ChatGPT Claude

Claude Perplexity

Perplexity Copilot

Copilot Gemini

Gemini Without Proper Instructions With Specific Instructions Without Proper Instructions Without Proper Instructions With Specific Instructions With Specific Instructions ChatGPT ChatGPT ChatGPT ChatGPT ChatGPT ChatGPT ChatGPT ChatGPT Claude Claude Claude Claude Claude Claude Claude Claude Perplexity Perplexity Perplexity Perplexity Perplexity Perplexity Perplexity Perplexity Copilot Copilot Copilot Copilot Copilot Copilot Copilot Copilot Gemini Gemini Gemini Gemini Gemini Gemini 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. Python Java 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. C# Java 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-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-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-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-xxv https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-viii-8mn3352 https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-viii-8mn3352 Disclaimer: Code Smells are my opinion. Disclaimer: Code Smells are my opinion. Disclaimer: Code Smells are my opinion . opinion Credits: Photo by Matt Artz on Unsplash Credits: Photo by Matt Artz on Unsplash Credits: Photo by Matt Artz on Unsplash Matt Artz Unsplash Inheritance is good, but you should never forget that it introduces tight coupling. Inheritance is good, but you should never forget that it introduces tight coupling. Robert C. Martin Robert C. Martin https://hackernoon.com/400-thought-provoking-software-engineering-quotes?embedable=true https://hackernoon.com/400-thought-provoking-software-engineering-quotes?embedable=true This article is part of the CodeSmell Series on HackerNoon. This article is part of the CodeSmell Series on HackerNoon. 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 https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-i-xqz3evd?embedable=true

Walkthroughs, tutorials, guides, and tips. This story will teach you how to do something new or how to do something better.

Code Smell 286 - Parent-Child Method Overlaps

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

10 Predictions About the Future of Finance

106 Stories To Learn About Clean Code

100 Pieces of Programming Advice from the Book Clean Code by Robert Martin

110 Stories To Learn About Refactoring

3 Things Coding And Prose Writing Have In Common According To Cory House

4 Simple Habits For Engineering Teams To Beat Technical Debt

10 Predictions About the Future of Finance

106 Stories To Learn About Clean Code

100 Pieces of Programming Advice from the Book Clean Code by Robert Martin

110 Stories To Learn About Refactoring

3 Things Coding And Prose Writing Have In Common According To Cory House

4 Simple Habits For Engineering Teams To Beat Technical Debt

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps