Composition vs Inheritance

Composition vs Inheritance is one of the most important design decisions in object-oriented programming. Let’s dive deep with code, principles, and practical examples.#

🧠 What Are They?#

They are both ways to reuse and organize code, but they serve different design goals.

🧬 Inheritance — “is-a” Relationship#

✅ When to Use:#

• When two classes share a hierarchical relationship.
• When you want to extend or specialize the behavior of a base class.

📦 Example:#

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

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

🔎 What’s happening?#

• Car inherits start() from Engine.
• But this creates a tight coupling — Car is forced to be an Engine, which might not be accurate.

🔧 Composition — “has-a” Relationship#

✅ When to Use:#

• When two classes are not logically in a strict hierarchy.
• When you want flexibility, loose coupling, and better testability.

📦 Example:#

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

class Car {
    private Engine engine = new Engine(); // Composition

    void startCar() {
        engine.start(); // Delegation
        System.out.println("Car is ready to drive");
    }
}

🔎 What’s happening?#

• Car has an Engine, but is not an engine.
• This is cleaner and more realistic — behavior is delegated rather than inherited.

⚖️ Composition vs Inheritance: Design Comparison#

💡 Design Principle#

Favor composition over inheritance — (Effective Java, Item 18)

Inheritance is powerful but often overused. Composition leads to better encapsulation, flexibility, and maintainability.

🔁 Hybrid Example#

You can even mix both:

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

class Vehicle {
    Engine engine = new Engine(); // Composition

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

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

Here, Car inherits from Vehicle, and Vehicle uses composition for Engine.

🏠 Homework for Students#

📌 Task:#

1. Inheritance:

   • Create a class Bird with a method fly().
   • Create a subclass Sparrow that adds method sing().

2. Composition:

   • Create a class Speaker with a method playMusic().
   • Create a class Smartphone that has a Speaker object and a method playSong() which delegates to playMusic().

3. Questions to Answer (in comments or writeup):

   • Which approach is more flexible and why?
   • What happens if you need to change Speaker logic in the future?
   • Can you reuse Speaker in another class without changing it?

Would you like to move next into Static Keyword, Final Keyword, or Association vs Aggregation vs Composition for a deeper dive into OOP relationships?