Delegation vs Inheritance in Java

Delegation and inheritance are two important concepts in Java object-oriented programming that allow classes to reuse code and share functionality.

Delegation is a design pattern where an object delegates a responsibility or a task to another object. In other words, instead of inheriting behavior from a superclass, the class contains a reference to an instance of another class, which performs the required behavior. This is often referred to as the "has-a" relationship.

Here's an example of delegation in Java:

public interface ILogger {
    void log(String message);
}

public class ConsoleLogger implements ILogger {
    @Override
    public void log(String message) {
        System.out.println(message);
    }
}

public class MyClass {
    private ILogger logger;
    
    public MyClass() {
        this.logger = new ConsoleLogger();
    }
    
    public void doSomething() {
        this.logger.log("Doing something");
    }
}

In this example, MyClass delegates the responsibility of logging messages to an instance of ConsoleLogger, which implements the ILogger interface. The MyClass constructor creates a new instance of ConsoleLogger, which is stored in the logger field. When the doSomething() method is called, it calls the log() method on the logger instance to perform the logging.

Inheritance, on the other hand, is a mechanism where a class can derive properties and behaviors from a base class. The subclass inherits all the methods and fields of the superclass, and can also override or add new methods and fields. This is often referred to as the "is-a" relationship.

Here's an example of inheritance in Java:

public class Animal {
    public void eat() {
        System.out.println("Eating...");
    }
}

public class Dog extends Animal {
    public void bark() {
        System.out.println("Barking...");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();  // Output: Eating...
        dog.bark(); // Output: Barking...
    }
}

In this example, the Dog class inherits the eat() method from the Animal class. It also adds a new method, bark(), which is specific to dogs. When an instance of Dog is created and the eat() and bark() methods are called, the output will be "Eating..." and "Barking...", respectively.

In summary, delegation and inheritance are both important concepts in Java programming, but they serve different purposes. Delegation is useful for modularizing behavior and reducing coupling, while inheritance is useful for creating hierarchies of related classes and reusing code.