What is composition vs inheritance?

In the realm of software development, particularly in object-oriented programming, the concepts of composition and inheritance are fundamental to structuring code effectively. Both approaches allow developers to create reusable and maintainable code, but they do so in different ways. Understanding the differences, advantages, and disadvantages of each can significantly impact the design of applications.

Inheritance is a mechanism where a new class derives properties and behaviors (methods) from an existing class. This creates a parent-child relationship between classes, allowing the child class to inherit attributes and methods from the parent class. While inheritance can promote code reuse, it can also lead to tight coupling and a rigid class hierarchy.

On the other hand, composition involves building complex types by combining objects or classes with distinct functionalities. Instead of inheriting behavior from a parent class, a class can contain instances of other classes, leveraging their capabilities. This approach promotes flexibility and allows for dynamic behavior changes at runtime.

Inheritance

Inheritance is often used to model "is-a" relationships. For example, if we have a base class called `Animal`, we can create subclasses like `Dog` and `Cat` that inherit from `Animal`.

class Animal {
    constructor(name) {
        this.name = name;
    }
    speak() {
        console.log(`${this.name} makes a noise.`);
    }
}

class Dog extends Animal {
    speak() {
        console.log(`${this.name} barks.`);
    }
}

class Cat extends Animal {
    speak() {
        console.log(`${this.name} meows.`);
    }
}

const dog = new Dog('Rex');
const cat = new Cat('Whiskers');
dog.speak(); // Rex barks.
cat.speak(); // Whiskers meows.

Advantages of Inheritance

• Code Reusability: Common functionality can be defined in a base class, reducing redundancy.
• Polymorphism: Subclasses can override methods of the parent class, allowing for dynamic method resolution.
• Clear Hierarchy: Inheritance creates a clear structure for the relationships between classes.

Disadvantages of Inheritance

• Tight Coupling: Subclasses are tightly coupled to their parent classes, making changes difficult.
• Fragile Base Class Problem: Changes in the base class can inadvertently affect subclasses.
• Complexity: Deep inheritance hierarchies can become complex and hard to manage.

Composition

Composition is often used to model "has-a" relationships. Instead of inheriting behavior, a class can include instances of other classes to achieve desired functionality. For instance, if we have a `Car` class, it can be composed of `Engine` and `Wheel` classes.

class Engine {
    start() {
        console.log('Engine starts.');
    }
}

class Wheel {
    rotate() {
        console.log('Wheel is rotating.');
    }
}

class Car {
    constructor() {
        this.engine = new Engine();
        this.wheel = new Wheel();
    }
    drive() {
        this.engine.start();
        this.wheel.rotate();
        console.log('Car is driving.');
    }
}

const car = new Car();
car.drive(); // Engine starts. Wheel is rotating. Car is driving.

Advantages of Composition

• Loose Coupling: Components can be changed independently without affecting others.
• Flexibility: New functionality can be added by composing new classes without altering existing ones.
• Dynamic Behavior: Composition allows for changing behaviors at runtime by swapping out components.

Disadvantages of Composition

• Complexity: Managing multiple objects can lead to increased complexity in some cases.
• Overhead: There may be a slight performance overhead due to additional object creation.

Best Practices

When deciding between composition and inheritance, consider the following best practices:

• Favor composition over inheritance to promote flexibility and reduce coupling.
• Use inheritance when there is a clear "is-a" relationship and when polymorphism is beneficial.
• Keep class hierarchies shallow to avoid complexity and maintainability issues.
• Utilize interfaces or abstract classes to define contracts for behavior when using inheritance.

Common Mistakes

Developers often make several common mistakes when using inheritance and composition:

• Creating deep inheritance hierarchies that complicate code maintenance.
• Overusing inheritance for code reuse instead of considering composition.
• Neglecting to encapsulate behavior properly, leading to tightly coupled code.

In conclusion, both composition and inheritance have their place in software design. Understanding when to use each approach can lead to more robust, maintainable, and scalable applications.