What are the alternatives to inheritance in…

Composition: An object contains other objects as its fields. The "has-a" relationship, unlike "is-a" (inheritance). It allows flexible changing of an object's behavior by substituting different implementations of the contained objects.

// Example of composition: class Car contains an Engine object
public class Engine {
    public void start() {
        System.out.println("Engine started.");
    }
}

public class Car {
    private Engine engine; // Composition: Car "has-a" Engine

    public Car(Engine engine) {
        this.engine = engine;
    }

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

Delegation: An object delegates the execution of a task to another object. Often used together with composition.

// Example of delegation in class Car
public class Car {
    private Engine engine;

    public Car(Engine engine) {
        this.engine = engine;
    }

    // Delegation: Car delegates engine start to the engine object
    public void start() {
        engine.start();
    }
}

Interfaces: Define a contract of behavior that can be implemented by multiple classes. Allows achieving polymorphism without a strict inheritance hierarchy.

// Example of using an interface
public interface Flyable {
    void fly();
}

public class Bird implements Flyable {
    @Override
    public void fly() {
        System.out.println("Bird is flying.");
    }
}

public class Airplane implements Flyable {
    @Override
    public void fly() {
        System.out.println("Airplane is flying.");
    }
}

Traits / Mixins (present in some languages like Scala, Groovy): Represent a set of methods that can be "mixed in" to a class. They enable reusing functionality across unrelated class hierarchies. In Java, they can be partially simulated using interfaces with default methods.

// Example of a mixin-like interface in Java using default methods
public interface Loggable {
    default void logInfo(String message) {
        System.out.println("[INFO] " + message);
    }

    default void logError(String message) {
        System.err.println("[ERROR] " + message);
    }
}

public class Process implements Loggable {
    public void execute() {
        logInfo("Executing process...");
        // ...
        logInfo("Process finished.");
    }
}

Aspect-Oriented Programming (AOP): Allows extracting cross-cutting concerns (logging, security, etc.) into separate modules (aspects) and "weaving" them into various parts of the application without modifying the original class code.

Each alternative has its advantages and disadvantages. The choice depends on the specific task and requirements for flexibility, code reuse, and architecture complexity. Composition, delegation, and interface usage are often preferred over direct inheritance, especially when inheritance leads to rigid hierarchies or the "diamond problem".

What are the alternatives to inheritance in object-oriented programming?