Inheritance vs 🧩 Composition in Object-Oriented Programming

When designing software systems using Object-Oriented Programming (OOP), two powerful techniques to organize and reuse code are inheritance and composition. While both achieve code reuse, they differ significantly in how they model relationships between objects.

Understanding the difference is crucial for building clean, maintainable, and scalable software. Let’s dive into their definitions, use-cases, and differences.

---

📘 What is Inheritance?

Inheritance is when one class (the child/subclass) derives from another class (the parent/base class) and inherits its attributes and methods.

🔗 Relationship: "Is-a"

If Dog inherits from Animal, then a Dog is an Animal.

✅ Example:

class Animal:
    def speak(self):
        print("Animal speaks")

class Dog(Animal):
    def speak(self):
        print("Dog barks")

d = Dog()
d.speak()

💡 Output:

Dog barks

Here, Dog overrides the speak() method of Animal, demonstrating method overriding.

---

🧩 What is Composition?

Composition means that one class contains an instance of another class and delegates work to it. Instead of inheriting, it uses the capabilities of other classes by composing them together.

🔗 Relationship: "Has-a"

If Car contains an Engine, then a Car has an Engine.

✅ Example:

class Engine:
    def start(self):
        print("Engine starts")

class Car:
    def __init__(self):
        self.engine = Engine()

    def start(self):
        self.engine.start()

c = Car()
c.start()

💡 Output:

Engine starts

---

🔍 Inheritance vs Composition: Head-to-Head

---

⚠️ Real-World Scenarios

🧬 Inheritance:

Use when there's a clear type hierarchy.

class Person:
    def get_id(self):
        return "Generic ID"

class Employee(Person):
    def get_id(self):
        return "Employee ID"

🧩 Composition:

Use when you want to plug in behaviors or combine functionalities.

class Logger:
    def log(self, msg):
        print(f"Log: {msg}")

class Service:
    def __init__(self):
        self.logger = Logger()

    def run(self):
        self.logger.log("Service started")

🧠 When to Use Which?

---

🏁 Conclusion

Both inheritance and composition are foundational to OOP, but serve different purposes.

• Use inheritance for strongly related types that share behavior.

• Use composition when building modular, flexible systems that need to evolve easily.

In modern software design, especially in large systems, composition is often preferred — summarized by the principle:

“Favor composition over inheritance.”