Composition vs Inheritance: Making the Right Choice in Object-Oriented Design

Intro: Why This Matters

In object-oriented programming (OOP), two foundational concepts shape how we build and structure code: composition and inheritance. While both are powerful, understanding when to use one over the other is crucial for writing maintainable, scalable, and robust code.

In this masterclass, we'll explore the core differences between composition and inheritance, when to use each, and how to avoid the common pitfalls of class design.

Core Concept: Inheritance

Inheritance allows a class to inherit properties and methods from a parent class. It's a way to model an "is-a" relationship. For example, a Car is a type of Vehicle.

However, inheritance can lead to tight coupling and fragile hierarchies if overused. This is where composition often becomes a better alternative.

Core Concept: Composition

Composition models a "has-a" relationship. Instead of inheriting behavior, a class is composed of other objects. This approach is more flexible and avoids the tight coupling of inheritance.

For example, a Car has an Engine and Wheels, but it doesn't *be* an engine. This is a more modular and reusable design pattern.

Visual Comparison: Inheritance vs Composition

Key Takeaways

• Inheritance is best for "is-a" relationships.
• Composition is best for "has-a" relationships and promotes flexibility.
• Prefer composition over inheritance to avoid tight coupling and brittle class hierarchies.

Code Example: Inheritance

class Vehicle {
    void move() {
        System.out.println("Vehicle is moving");
    }
}

class Car extends Vehicle {
    void honk() {
        System.out.println("Car is honking");
    }
}
  

Code Example: Composition

class Engine {
    void start() {
        System.out.println("Engine started");
    }
}

class Car {
    private Engine engine;

    Car() {
        this.engine = new Engine();
    }

    void startCar() {
        engine.start();
    }
}
  

When to Use What

• Use inheritance when there is a clear "is-a" relationship and you want to reuse behavior from a parent class.
• Use composition when you want to build flexible, decoupled systems that are easier to maintain and extend.

For more information on choosing the right design, see our guide on favoring composition over inheritance.

Diagram: Inheritance vs Composition

Conclusion

Choosing between composition and inheritance is a foundational decision in object-oriented design. While both are powerful, composition often leads to more maintainable and flexible systems. For more on this, see our guide on composition vs inheritance in OOP.

Understanding Inheritance

Inheritance is one of the four core principles of Object-Oriented Programming (OOP). It allows a class to inherit attributes and methods from another class, promoting code reusability and establishing a natural hierarchy between classes.

Example: Parent-Child Relationship

Here’s a simple example of inheritance in code:

class Vehicle {
  void start() {
    System.out.println("Vehicle is starting");
  }
}

class Car extends Vehicle {
  void drive() {
    System.out.println("Car is driving");
  }
}
  

In this example, Car inherits from Vehicle, gaining access to its start method. This is the "is-a" relationship in action.

Why Use Inheritance?

Inheritance allows you to build new classes that are built upon, or derived from, existing classes. The new class "inherits" the properties and methods of the base class, enabling code reusability and a logical structure.

It's essential to understand when to use inheritance. For more on this, see our guide on composition vs inheritance in OOP.

Types of Inheritance

• Single Inheritance: A class inherits from one parent class.
• Multiple Inheritance: A class inherits from more than one class. (Note: Java doesn't support this directly, but C++ does.)
• Multilevel Inheritance: A class inherits from a derived class, forming a chain.
• Hierarchical Inheritance: Multiple classes inherit from a single base class.

Example: Java Inheritance

class Animal {
  void eat() {
    System.out.println("Animal is eating");
  }
}

class Dog extends Animal {
  void bark() {
    System.out.println("Dog is barking");
  }
}
  

In this example, Dog inherits the eat method from Animal, demonstrating the "is-a" relationship.

Key Takeaways

• Inheritance allows one class to acquire the properties and methods of another.
• It promotes reusability and establishes a class hierarchy.
• It is crucial to understand when to use inheritance over composition. For more, see composition vs inheritance in OOP.

Composition vs Inheritance: A Quick Recap

class Animal { ... }
class Dog extends Animal { ... }

class Engine { ... }
class Car {
  private Engine engine;
}

Composition in Action: A Real-World Example

Let’s model a Computer class that is composed of a CPU, RAM, and Storage.

class CPU {
  void execute() {
    System.out.println("CPU is executing instructions");
  }
}

class RAM {
  void load() {
    System.out.println("RAM is loading data");
  }
}

class Storage {
  void read() {
    System.out.println("Storage is reading data");
  }
}

class Computer {
  private CPU cpu;
  private RAM ram;
  private Storage storage;

  public Computer() {
    this.cpu = new CPU();
    this.ram = new RAM();
    this.storage = new Storage();
  }

  public void start() {
    storage.read();
    ram.load();
    cpu.execute();
    System.out.println("Computer started successfully!");
  }
}

In this example, Computer is composed of other objects — it has a CPU, RAM, and Storage.

Visualizing Composition with Mermaid.js

Animating Composition with Anime.js

Below is a conceptual animation of how components interact in a composed object:

Key Takeaways

• Composition models a "has-a" relationship, unlike inheritance's "is-a".
• It promotes modularity, reusability, and flexibility in design.
• It's often preferred over inheritance for building maintainable systems.
• For a deeper dive into when to use composition over inheritance, see composition vs inheritance in OOP.

Inheritance vs Composition: A Quick Recap

Using Inheritance (Rigid and Brittle)

class Character { }
class FlyingCharacter extends Character { }
class SwimmingCharacter extends Character { }
class FlyingSwimmingCharacter extends Character { } // Problematic!
  

Using Composition (Flexible and Scalable)

interface Ability { void use(); }

class FlyAbility implements Ability {
    public void use() { System.out.println("Flying!"); }
}

class SwimAbility implements Ability {
    public void use() { System.out.println("Swimming!"); }
}

class Character {
    private List<Ability> abilities = new ArrayList<>();

    public void addAbility(Ability ability) {
        abilities.add(ability);
    }

    public void useAbilities() {
        for (Ability ability : abilities) {
            ability.use();
        }
    }
}
  

Visualizing the Flexibility

Comparison Table: Inheritance vs Composition

Key Takeaways

• Composition promotes loose coupling and high cohesion, making systems easier to maintain.
• It avoids the pitfalls of deep inheritance hierarchies, such as the fragile base class problem.
• It enables dynamic behavior at runtime, unlike static inheritance.
• For a deeper dive into when to use composition over inheritance, see composition vs inheritance in OOP.

Quick Comparison: Inheritance vs Composition

// Parent class
class Animal {
  public void makeSound() {
    System.out.println("Some generic animal sound");
  }
}

// Child class
class Dog extends Animal {
  @Override
  public void makeSound() {
    System.out.println("Bark!");
  }
}

// Usage
Dog dog = new Dog();
dog.makeSound(); // Outputs: Bark!
  

// Sound behavior interface
interface SoundBehavior {
  void makeSound();
}

// Concrete behavior
class BarkSound implements SoundBehavior {
  public void makeSound() {
    System.out.println("Bark!");
  }
}

// Composed class
class Dog {
  private SoundBehavior soundBehavior;

  public Dog(SoundBehavior soundBehavior) {
    this.soundBehavior = soundBehavior;
  }

  public void performSound() {
    soundBehavior.makeSound();
  }
}

// Usage
Dog dog = new Dog(new BarkSound());
dog.performSound(); // Outputs: Bark!
  

When to Choose What?

• Use Inheritance when:
  • You are modeling a natural hierarchy (e.g., Animal → Dog → Labrador).
  • You want to reuse method implementations across subclasses.
  • You are working with frameworks that expect inheritance (e.g., Java Swing, Android).
• Use Composition when:
  • You want to avoid tight coupling and fragile base class issues.
  • You need to swap behaviors at runtime (Strategy Pattern).
  • You're following the favoring composition over inheritance principle.

Visualizing the Flow: Composition vs Inheritance

Key Takeaways

• Inheritance is powerful but can lead to rigid structures. Use it wisely.
• Composition offers flexibility and is the preferred method in modern OOP design.
• Prefer composition when behavior needs to change at runtime or when you want to avoid deep inheritance trees.
• For a deeper dive into when to use each approach, check out composition vs inheritance in OOP.

Key Takeaways

• 'is-a' relationships model the inheritance hierarchy (e.g., a Car is-a Vehicle).
• 'has-a' relationships represent composition (e.g., a Car has-a Engine).

Key Takeaways

• Inheritance is used to model 'is-a' relationships.
• Composition is used to model 'has-a' relationships.
• Prefer composition when designing for flexibility and modularity.
• For a deeper dive into when to use each approach, check out composition vs inheritance in OOP.

Composition in Action: Car System

Code Example: Car Composition

// Engine class
class Engine {
    private String type;

    public Engine(String type) {
        this.type = type;
    }

    public void start() {
        System.out.println(type + " engine started.");
    }
}

// Wheel class
class Wheel {
    private String size;

    public Wheel(String size) {
        this.size = size;
    }

    public void rotate() {
        System.out.println(size + " wheel rotating.");
    }
}

// Car class composed of Engine and Wheels
class Car {
    private Engine engine;
    private Wheel[] wheels;

    public Car(Engine engine, Wheel[] wheels) {
        this.engine = engine;
        this.wheels = wheels;
    }

    public void drive() {
        engine.start();
        for (Wheel wheel : wheels) {
            wheel.rotate();
        }
        System.out.println("Car is moving!");
    }
}
    

Key Takeaways

• Composition models 'has-a' relationships, making systems flexible and modular.
• Unlike inheritance, composition allows runtime flexibility and easier testing.
• Real-world analogies like cars help visualize how objects are composed of parts.
• Prefer composition when designing for scalability and maintainability.
• For more on this topic, see our guide on favoring composition over inheritance.

Visualizing the Fragile Base Class Problem

Example: Breaking Change in Base Class

// Base class
public class Vehicle {
    protected int speed;

    // Constructor added later
    public Vehicle(int speed) {
        this.speed = speed;
    }

    // New method added to base class
    public void setSpeed(int speed) {
        this.speed = speed;
    }
}

// Derived class
public class Car extends Vehicle {
    public Car() {
        super(0); // Now required due to new constructor
    }
}
  

Pro-Tip: Prefer Composition Over Inheritance

Instead of inheriting behavior, consider composing objects to achieve flexibility and reduce coupling. This approach avoids the fragile base class problem by design.

Key Takeaways

• The Fragile Base Class Problem occurs when changes to a base class unintentionally break derived classes.
• It highlights the dangers of tight coupling in inheritance hierarchies.
• Using composition instead of inheritance leads to more robust and maintainable systems.
• Always evaluate whether inheritance truly models an "is-a" relationship or if composition better suits your design.
• For more on this topic, see our guide on favoring composition over inheritance.

Why Composition Wins Over Inheritance

Inheritance models an "is-a" relationship, while composition models a "has-a" relationship. This subtle shift in thinking can dramatically improve code quality.

class Logger:
    def log(self, message):
        print(f"[LOG] {message}")

class Encryptor:
    def encrypt(self, data):
        return f"Encrypted({data})"

class Car:
    def __init__(self, logger, encryptor):
        self.logger = logger
        self.encryptor = encryptor

    def start(self):
        self.logger.log("Car started")
        encrypted = self.encryptor.encrypt("start_sequence")
        print(f"Encrypted command: {encrypted}")

# Usage
logger = Logger()
encryptor = Encryptor()
car = Car(logger, encryptor)
car.start()

Key Takeaways

• Composition favors flexibility and modularity over rigid class hierarchies.
• It enables dynamic behavior through component swapping and dependency injection.
• It avoids the Fragile Base Class Problem by decoupling behavior from structure.
• Use composition when behavior needs to be shared across unrelated classes.
• For more on this design philosophy, see our guide on favoring composition over inheritance.

Why Composition Wins Over Inheritance

When building flexible and maintainable systems, composition is your secret weapon. Unlike inheritance, which can lead to rigid class hierarchies, composition allows you to swap out behaviors dynamically at runtime. This is the heart of the Strategy pattern — a behavioral design pattern that enables selecting an algorithm at runtime.

Let’s visualize how composition enables this powerful design approach.

Example: Strategy Pattern with Python

Here’s how you can implement the Strategy pattern in Python using composition:

# Strategy Interface
class EncryptionStrategy:
    def encrypt(self, data):
        raise NotImplementedError

# Concrete Strategies
class AESEncryption(EncryptionStrategy):
    def encrypt(self, data):
        return f"AES encrypted: {data}"

class RSACryption(EncryptionStrategy):
    def encrypt(self, data):
        return f"RSA encrypted: {data}"

# Context using composition
class DataProcessor:
    def __init__(self, encryption_strategy: EncryptionStrategy):
        self.encryption_strategy = encryption_strategy

    def process(self, data):
        return self.encryption_strategy.encrypt(data)

# Usage
aes = AESEncryption()
processor = DataProcessor(aes)
print(processor.process("mydata"))  # Output: AES encrypted: mydata

Strategy Pattern Diagram

Below is a Mermaid.js diagram showing how the Strategy pattern works with composition:

Key Takeaways

• Composition allows you to build flexible, maintainable systems by plugging in different behaviors at runtime.
• The Strategy pattern is a prime example of composition in action, enabling you to swap out algorithms dynamically.
• Unlike inheritance, composition avoids tight coupling and allows for better testability and modularity.
• For more on the power of composition, see our guide on composition vs inheritance.

Why LSP Matters

• Ensures polymorphism works correctly
• Prevents unexpected behavior in derived classes
• Improves code maintainability and scalability

Key Takeaways

• LSP ensures that derived classes can be used interchangeably with their base class.
• Violating LSP leads to fragile code and unexpected behavior.
• Always design subclasses to fully honor the contracts of their parent classes.
• For more on object-oriented design principles, see our guide on composition vs inheritance.

Before: Inheritance-Based Design

Here's a typical inheritance-heavy class structure:

// Legacy class using inheritance
class Bird {
  void fly() { System.out.println("Bird is flying"); }
}

class Eagle extends Bird {
  void fly() { System.out.println("Eagle soars high"); }
}
  

After: Composition-Based Design

Refactored to use composition:

interface Flyable {
  void fly();
}

class Bird {
  private Flyable flightBehavior;

  public Bird(Flyable flightBehavior) {
    this.flightBehavior = flightBehavior;
  }

  public void performFly() {
    flightBehavior.fly();
  }
}

class SoarFlight implements Flyable {
  public void fly() {
    System.out.println("Soaring high in the sky");
  }
}
  

Visualizing the Refactor

Composition Refactor

Key Takeaways

• Composition offers more flexibility than deep inheritance trees.
• Refactoring to composition reduces coupling and increases testability.
• Use interfaces and delegation to enable behavior dynamically.
• For more on this design philosophy, see our guide on composition over inheritance.

Scenario: Building a Game Character System

We want to model characters in a game. Each character can move, attack, and defend. Some characters can fly, others can swim, and some can do both. Let’s compare how inheritance and composition handle this.

Performance & Flexibility: Animated Comparison

Key Takeaways

• Inheritance is intuitive but leads to rigid structures and hard-to-maintain hierarchies.
• Composition allows dynamic behavior assignment and promotes loose coupling.
• Prefer composition when behavior changes at runtime or when multiple behaviors are needed.
• For more on this design philosophy, see our guide on composition over inheritance.

Top OOP Pitfalls and Code Smells

Key Takeaways

• God Objects lead to tight coupling and low cohesion—refactor into focused classes.
• Feature Envy signals misplaced logic—move methods closer to the data they operate on.
• Data Clumps should be encapsulated into their own classes or structs.
• Use composition over inheritance to avoid rigid hierarchies and promote flexibility.
• Always aim for high cohesion and loose coupling in your OOP designs.

Performance Metrics: Inheritance vs. Composition