Composition over inheritance in LLD - Deep Dive

Overview - Composition over inheritance

What is it?

Composition over inheritance is a design principle that suggests building complex systems by combining simpler parts rather than relying on class inheritance. Instead of creating a deep family tree of classes, you create objects that contain other objects to reuse functionality. This approach helps keep systems flexible and easier to change over time.

Why it matters

Without composition, systems often become rigid and hard to maintain because inheritance creates tight coupling and deep hierarchies. This can lead to fragile designs where a small change breaks many parts. Composition allows developers to mix and match behaviors, making software easier to extend and adapt to new requirements.

Where it fits

Before learning composition over inheritance, you should understand basic object-oriented programming concepts like classes and inheritance. After mastering this principle, you can explore design patterns like strategy, decorator, and dependency injection that rely heavily on composition.

Mental Model

Core Idea

Build complex behavior by assembling simple, reusable parts instead of extending classes through inheritance.

Think of it like...

It's like building a custom sandwich by choosing individual ingredients rather than ordering a fixed sandwich from a menu. You combine bread, cheese, veggies, and meat as you like, instead of picking a preset sandwich that might have unwanted items.

┌───────────────┐       ┌───────────────┐
│   Object A    │──────▶│  Behavior X   │
│ (has a part)  │       │ (component)   │
└───────────────┘       └───────────────┘
        │
        │
        ▼
┌───────────────┐       ┌───────────────┐
│   Object A    │──────▶│  Behavior Y   │
│ (has a part)  │       │ (component)   │
└───────────────┘       └───────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding inheritance basics

Concept: Inheritance allows a class to inherit properties and behaviors from another class, forming a hierarchy.

In object-oriented programming, inheritance means creating a new class based on an existing class. The new class (child) gets all the features of the existing class (parent) and can add or change some. For example, a 'Car' class might inherit from a 'Vehicle' class, gaining wheels and engine properties.

Result

You get a class hierarchy where child classes reuse code from parent classes.

Understanding inheritance is essential because composition is often compared to it; knowing its strengths and weaknesses helps appreciate composition.

2

Foundation

What is composition in design

Concept: Composition means building objects by combining other objects, each responsible for a part of the behavior.

Instead of inheriting from a parent class, an object contains other objects that provide specific features. For example, a 'Car' object might have an 'Engine' object and a 'Radio' object inside it. Each part handles its own behavior, and the car uses them together.

Result

Objects become flexible by assembling different parts rather than relying on a fixed class hierarchy.

Knowing composition as 'has-a' relationships helps see how it differs from inheritance's 'is-a' relationships.

3

Intermediate

Problems with deep inheritance trees

🤔Before reading on: do you think deep inheritance trees make code easier or harder to maintain? Commit to your answer.

Concept: Deep inheritance hierarchies create tight coupling and fragile designs that are hard to change.

When classes inherit from many levels, changes in a parent class can unexpectedly affect all child classes. This makes debugging and extending code difficult. Also, inheritance forces a fixed structure that may not fit new requirements well.

Result

Deep inheritance often leads to rigid, fragile systems that resist change.

Understanding these problems motivates the need for more flexible design approaches like composition.

4

Intermediate

How composition improves flexibility

🤔Before reading on: do you think composition allows changing behavior at runtime or only at compile time? Commit to your answer.

Concept: Composition allows swapping parts dynamically, making systems more adaptable.

Because objects contain other objects, you can replace or modify these parts without changing the whole system. For example, a car can swap its radio object for a new model without changing the car class. This supports easier updates and customization.

Result

Systems built with composition are easier to extend and maintain.

Knowing that composition supports dynamic behavior changes explains why it is preferred in many designs.

5

Intermediate

Common patterns using composition

Concept: Design patterns like strategy and decorator use composition to add or change behavior.

The strategy pattern lets you change an algorithm by swapping objects that implement it. The decorator pattern adds features by wrapping objects with others. Both rely on composing objects rather than inheriting from many classes.

Result

You can build flexible, reusable code by combining simple objects.

Recognizing these patterns shows how composition is a practical tool, not just a theory.

6

Advanced

Composition in large-scale systems

🤔Before reading on: do you think composition increases or decreases system complexity? Commit to your answer.

Concept: Composition helps manage complexity by breaking systems into smaller, independent parts.

In big systems, composition allows teams to develop, test, and deploy parts independently. Each component has a clear responsibility, reducing bugs and improving collaboration. It also supports microservices and modular architectures.

Result

Large systems become more maintainable and scalable with composition.

Understanding composition's role in modularity clarifies why it is favored in modern system design.

7

Expert

Trade-offs and pitfalls of composition

🤔Before reading on: do you think composition always leads to simpler code than inheritance? Commit to your answer.

Concept: While composition offers flexibility, it can introduce complexity in managing many small objects and their interactions.

Using many composed parts requires careful design to avoid excessive indirection and performance overhead. It can also make debugging harder if responsibilities are unclear. Balancing composition with simplicity is key.

Result

Expert use of composition involves trade-offs and thoughtful design decisions.

Knowing these trade-offs prevents blindly applying composition and encourages balanced architecture.

Under the Hood

Composition works by having objects hold references to other objects that implement specific behaviors. Instead of inheriting methods and properties, an object delegates tasks to its parts. This delegation happens at runtime, allowing dynamic behavior changes. Internally, this means method calls are forwarded to contained objects, enabling flexible combinations.

Why designed this way?

Composition was designed to overcome the rigidity and tight coupling of inheritance hierarchies. Early object-oriented designs suffered from deep inheritance trees that were hard to maintain. Composition offers a way to reuse code without forcing a fixed class structure, promoting modularity and adaptability.

┌───────────────┐
│   Main Object │
│  ┌─────────┐  │
│  │ Part A  │◀─┼─────┐
│  └─────────┘  │     │
│  ┌─────────┐  │     │
│  │ Part B  │◀─┼─────┼─ Delegation
│  └─────────┘  │     │
└───────────────┘     │
                      ▼
               ┌─────────────┐
               │ Behavior X  │
               └─────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does composition mean no inheritance is ever used? Commit to yes or no.

Common Belief: Composition completely replaces inheritance and inheritance should be avoided.

Reality: Composition complements inheritance; both have valid uses depending on the problem.

Why it matters: Avoiding inheritance entirely can lead to reinventing solutions and unnecessary complexity.

Quick: Is composition always simpler to implement than inheritance? Commit to yes or no.

Common Belief: Composition always leads to simpler and cleaner code than inheritance.

Reality: Composition can introduce complexity through many small objects and delegation layers.

Why it matters: Ignoring this can cause over-engineered designs that are hard to understand and debug.

Quick: Does inheritance always cause tight coupling? Commit to yes or no.

Common Belief: Inheritance always creates tight coupling and fragile code.

Reality: Properly used inheritance with clear boundaries can be clean and maintainable.

Why it matters: Misjudging inheritance can lead to rejecting useful design tools and patterns.

Quick: Can composition allow changing behavior at runtime? Commit to yes or no.

Common Belief: Inheritance and composition both only allow behavior changes at compile time.

Reality: Composition supports runtime behavior changes by swapping components dynamically.

Why it matters: Missing this limits understanding of composition's flexibility benefits.

Expert Zone

1

Composition requires clear ownership and lifecycle management of parts to avoid memory leaks or dangling references.

2

Excessive use of composition can lead to 'object soup' where too many small objects make the system hard to follow.

3

Combining inheritance and composition strategically often yields the best design, leveraging strengths of both.

When NOT to use

Avoid composition when the behavior naturally fits a strict hierarchy with shared implementation, where inheritance provides clarity and simplicity. Also, in performance-critical systems, excessive delegation from composition may add overhead. In such cases, prefer inheritance or flat structures.

Production Patterns

In real-world systems, composition is used in plugin architectures, UI component frameworks, and microservices. For example, React uses composition to build UI elements by nesting components. Strategy and decorator patterns in enterprise apps rely on composition to enable flexible business rules.

Connections

Modular programming

Composition builds on modular programming principles by assembling independent modules into larger systems.

Understanding modularity helps grasp how composition promotes separation of concerns and reusability.

Functional programming

Composition in object-oriented design parallels function composition in functional programming, where small functions combine to form complex behavior.

Seeing this connection reveals a universal pattern of building complexity from simple parts across paradigms.

Biology - Cellular systems

Composition resembles how cells form tissues and organs by combining specialized parts to create complex organisms.

Recognizing this natural parallel helps appreciate composition as a fundamental principle of building complexity.

Common Pitfalls

#1 Overusing inheritance to add features leads to deep, fragile class hierarchies.

Wrong approach:

class Vehicle {}
class Car extends Vehicle {}
class SportsCar extends Car {}
class ElectricSportsCar extends SportsCar {}

Correct approach:

class Vehicle {}
class Engine {}
class Radio {}
class Car {
constructor() {
this.engine = new Engine();
this.radio = new Radio();
}
}

Root cause:

Misunderstanding inheritance as the only way to reuse code causes rigid designs.

#2 Creating too many tiny components without clear responsibility causes confusion.

Wrong approach:

class Car {
constructor() {
this.part1 = new Part1();
this.part2 = new Part2();
this.part3 = new Part3();
this.part4 = new Part4();
this.part5 = new Part5();
}
}

Correct approach:

class Car {
constructor() {
this.engine = new Engine();
this.radio = new Radio();
}
}

Root cause:

Lack of clear design leads to unnecessary fragmentation and complexity.

#3 Assuming composition eliminates all coupling and complexity.

Wrong approach:

class Car {
constructor() {
this.engine = new Engine();
this.radio = new Radio();
}
start() {
this.engine.start();
this.radio.play();
}
// No clear interface or boundaries
}

Correct approach:

class Car {
constructor(engine, radio) {
this.engine = engine;
this.radio = radio;
}
start() {
this.engine.start();
this.radio.play();
}
}

Root cause:

Ignoring interface design and clear boundaries increases coupling despite composition.

Key Takeaways

Composition builds complex systems by combining simple, reusable parts rather than relying on class inheritance.

It offers greater flexibility and easier maintenance by allowing behavior to change dynamically through object composition.

Inheritance creates tight coupling and rigid hierarchies, which composition helps avoid by promoting modular design.

Both inheritance and composition have their place; expert design balances them based on problem needs.

Understanding composition deeply improves your ability to design scalable, adaptable, and maintainable software systems.