Understanding the differences between composition and inheritance is crucial for object-oriented programming. Common mistakes include misusing inheritance for code reuse instead of composition, leading to rigid structures that are hard to maintain and extend.
composition, inheritance, object-oriented programming, code reuse, software design, maintainability
// Example of Misusing Inheritance
class Animal {
public function makeSound() {
return "Some sound";
}
}
class Dog extends Animal {
public function makeSound() {
return "Bark";
}
}
// Composition example
class SoundBehavior {
public function makeSound() {
// Default behavior
return "Some sound";
}
}
class BarkBehavior extends SoundBehavior {
public function makeSound() {
return "Bark";
}
}
class Dog {
private $soundBehavior;
public function __construct(SoundBehavior $soundBehavior) {
$this->soundBehavior = $soundBehavior;
}
public function performSound() {
return $this->soundBehavior->makeSound();
}
}
$dog = new Dog(new BarkBehavior());
echo $dog->performSound(); // Outputs: Bark
How do I avoid rehashing overhead with std::set in multithreaded code?
How do I find elements with custom comparators with std::set for embedded targets?
How do I erase elements while iterating with std::set for embedded targets?
How do I provide stable iteration order with std::unordered_map for large datasets?
How do I reserve capacity ahead of time with std::unordered_map for large datasets?
How do I erase elements while iterating with std::unordered_map in multithreaded code?
How do I provide stable iteration order with std::map for embedded targets?
How do I provide stable iteration order with std::map in multithreaded code?
How do I avoid rehashing overhead with std::map in performance-sensitive code?
How do I merge two containers efficiently with std::map for embedded targets?