How Can I Reduce Code Duplication Without Using Subclass Inheritance?

What are effective methods to eliminate code duplication without relying on subclass inheritance in object-oriented programming?

Reducing code duplication, or improving code reusability, is a fundamental principle in software development that enhances maintainability and readability. Instead of using subclass inheritance, which can lead to a rigid architecture, alternative approaches can be employed, such as composition and the use of interfaces or abstractions. Here’s how to implement these strategies effectively.

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

class Car {
    private Engine engine = new Engine();
    
    public void drive() {
        engine.start();
        System.out.println("Car is driving");
    }
}

class Truck {
    private Engine engine = new Engine();
    
    public void haul() {
        engine.start();
        System.out.println("Truck is hauling");
    }
}  

// Usage
Car myCar = new Car();
myCar.drive();

Truck myTruck = new Truck();
myTruck.haul();  

// Output:
// Engine starts
// Car is driving
// Engine starts
// Truck is hauling

Causes

• Over-reliance on inheritance for code reuse
• Not encapsulating shared logic effectively
• Failure to recognize opportunities for composition

Solutions

• **Use Composition**: Combine simple classes that achieve specific functionalities and delegate responsibilities to them instead of inheriting from a base class. For example, if you have classes 'Car' and 'Truck', you can create a class 'Engine' that both 'Car' and 'Truck' can use, rather than creating a vehicle superclass.
• **Utilize Interfaces**: Define interfaces that declare methods which can be implemented by multiple classes. This allows different classes to provide their own unique implementations while guaranteeing they follow the same contract.
• **Design Patterns**: Implement patterns like Strategy, Decorator, or Adapter that inherently promote code reuse by allowing interchangeable components without the need for a strict hierarchy.

Mistake: Using inheritance for shared behavior that could be achieved with composition.

Solution: Examine shared behaviors that can be encapsulated using separate classes or interfaces.

Mistake: Creating deep inheritance trees which lead to unmanageable code.

Solution: Prefer composition to create relationships and delegate responsibilities among smaller, cohesive classes.