Composition Over Inheritance in PHP

Object-oriented programming (OOP) is a core principle in PHP that allows developers to build modular, reusable, and scalable applications. Two of the most commonly used OOP concepts are composition and inheritance. Each plays a significant role in designing robust applications but has distinct implications for code structure, flexibility, and maintainability.

In this blog post, we’ll explore the differences between composition and inheritance, discuss when to use each, and provide PHP examples to illustrate their use cases.

Understanding Composition and Inheritance

Inheritance

Inheritance is an OOP concept where one class (child) inherits properties and methods from another class (parent). This creates a hierarchical relationship where the child class is a specialized version of the parent class. The keyword extends is used in PHP to define this relationship.

Example: Inheritance in PHP

class Animal {
    public function makeSound() {
        echo "Some generic animal sound";
    }
}

class Dog extends Animal {
    public function makeSound() {
        echo "Bark!";
    }
}

$dog = new Dog();
$dog->makeSound(); // Output: Bark!

In this example, the Dog class inherits from the Animal class and overrides the makeSound method. This example shows inheritance as a way to create a specialized version of an existing class.

Composition

Composition, on the other hand, is a design principle where classes are built by combining other classes, rather than inheriting from them. In composition, an object can be composed of several objects that it "has," rather than "is." This concept aligns with the principle of “composition over inheritance,” where we favor creating objects with various capabilities rather than relying solely on a class hierarchy.

Example: Composition in PHP

class Engine {
    public function start() {
        echo "Engine started";
    }
}

class Car {
    private $engine;

    public function __construct() {
        $this->engine = new Engine();
    }

    public function startEngine() {
        $this->engine->start();
    }
}

$car = new Car();
$car->startEngine(); // Output: Engine started

In this example, a Car object has an Engine object. The Car class doesn’t inherit from Engine; instead, it uses composition to include an Engine object as a property.

Key Differences Between Composition and Inheritance

1. Relationship Type

Inheritance establishes an “is-a” relationship. For example, a Dog is an Animal.
Composition establishes a “has-a” relationship. For example, a Car has an Engine.

2. Flexibility and Reusability

Inheritance can lead to rigid structures. If you need to change or extend functionality, you may need to adjust the hierarchy.
Composition offers greater flexibility as objects are composed of different components, making it easier to modify, add, or swap components without impacting the entire structure.

3. Multiple Behaviors

Inheritance only allows a single parent class due to PHP's single inheritance limitation. This can restrict the ability to add multiple behaviors.
Composition allows the inclusion of multiple, varied objects, which makes it easier to compose an object with different functionalities.

4. Encapsulation

Inheritance can break encapsulation if subclasses depend too much on the inner workings of the parent class.
Composition promotes better encapsulation since classes expose only the necessary interfaces.

When to Use Inheritance in PHP

Inheritance can be effective when:

There is a clear “is-a” relationship.
You are building a class hierarchy where specialized child classes share a lot of behavior with their parent class.
You don’t need multiple types of functionality for an object.

Example Use Case of Inheritance

Consider a situation where you have multiple types of vehicles, and each vehicle type shares basic functionalities like move() and stop(), but each has a unique implementation.

abstract class Vehicle {
    abstract public function move();
}

class Bike extends Vehicle {
    public function move() {
        echo "Bike is moving";
    }
}

class Car extends Vehicle {
    public function move() {
        echo "Car is moving";
    }
}

When to Use Composition in PHP

Composition is generally more useful when:

You need to combine different behaviors or properties in an object.
You want flexibility to change or extend functionalities independently.
You want to avoid the complexities of a rigid inheritance hierarchy.

Example Use Case of Composition

Consider a Person class where each person has various traits like walking, talking, and running. You can compose these traits independently, so each person can have different behaviors based on the assigned classes.

class WalkBehavior {
    public function walk() {
        echo "Walking";
    }
}

class TalkBehavior {
    public function talk() {
        echo "Talking";
    }
}

class Person {
    private $walkBehavior;
    private $talkBehavior;

    public function __construct(WalkBehavior $walk, TalkBehavior $talk) {
        $this->walkBehavior = $walk;
        $this->talkBehavior = $talk;
    }

    public function walk() {
        $this->walkBehavior->walk();
    }

    public function talk() {
        $this->talkBehavior->talk();
    }
}

$person = new Person(new WalkBehavior(), new TalkBehavior());
$person->walk(); // Output: Walking
$person->talk(); // Output: Talking

In this scenario, different behaviors (walk, talk) are added to the Person class through composition, making it easy to extend and modify behaviors without altering the structure of the Person class.

Benefits of Composition Over Inheritance

Decoupling and Reusability: Composition allows for more modular classes where individual parts can be reused and modified without affecting others.
Improved Testing: With composition, individual components can be tested in isolation.
Enhanced Maintainability: As applications grow, composition makes it easier to maintain and refactor code.

Drawbacks of Composition

Increased Complexity: Composition can sometimes make code harder to understand, as it requires managing more objects.
More Boilerplate Code: Since you have to manually assign and initialize components, the code might become more verbose.

Benefits of Inheritance Over Composition

Simpler and More Intuitive: Inheritance is often simpler to understand and implement, especially for “is-a” relationships.
Efficient Code Organization: By inheriting from a parent class, you can minimize code repetition and centralize shared logic.

Drawbacks of Inheritance

Rigid Structure: Inheritance can create a rigid hierarchy, making it harder to adapt or extend functionality without affecting the entire hierarchy.
Potential for Fragile Base Classes: Changes in a parent class can inadvertently break functionality in child classes, leading to unpredictable behavior.

Conclusion: Composition vs Inheritance in PHP

Choosing between composition and inheritance depends largely on the problem at hand and the relationships between your objects:

Use inheritance for clear “is-a” relationships with shared behavior, such as in cases where the child class is simply a specialized version of the parent.
Use composition for “has-a” relationships or when you want flexibility to add, change, or replace functionalities independently.

By thoughtfully choosing between inheritance and composition, you can design more adaptable, maintainable, and scalable PHP applications. Remember, it’s not about choosing one over the other exclusively but understanding when each approach best suits your application’s needs.