How do I implement the Mediator pattern in Java?

How do I implement the Mediator pattern in Java?

The Mediator pattern is a behavioral design pattern that allows objects to communicate with each other without knowing about each other's internal details. In Java, you can implement it by creating a Mediator interface and concrete Mediator classes.

Can you provide a simple code example?

Sure! Here's a basic example:

// Mediator Interface
interface Mediator {
    void send(String message, Colleague colleague);
}

// Concrete Mediator
class ConcreteMediator implements Mediator {
    private ColleagueA colleagueA;
    private ColleagueB colleagueB;

    public void setColleagueA(ColleagueA colleagueA) {
        this.colleagueA = colleagueA;
    }

    public void setColleagueB(ColleagueB colleagueB) {
        this.colleagueB = colleagueB;
    }

    public void send(String message, Colleague colleague) {
        if (colleague == colleagueA) {
            colleagueB.receive(message);
        } else {
            colleagueA.receive(message);
        }
    }
}

// Colleague Interface
abstract class Colleague {
    protected Mediator mediator;
    public Colleague(Mediator mediator) {
        this.mediator = mediator;
    }
    public abstract void send(String message);
    public abstract void receive(String message);
}

// Concrete Colleagues
class ColleagueA extends Colleague {
    public ColleagueA(Mediator mediator) {
        super(mediator);
    }
    public void send(String message) {
        System.out.println("ColleagueA sending: " + message);
        mediator.send(message, this);
    }
    public void receive(String message) {
        System.out.println("ColleagueA received: " + message);
    }
}

class ColleagueB extends Colleague {
    public ColleagueB(Mediator mediator) {
        super(mediator);
    }
    public void send(String message) {
        System.out.println("ColleagueB sending: " + message);
        mediator.send(message, this);
    }
    public void receive(String message) {
        System.out.println("ColleagueB received: " + message);
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        ConcreteMediator mediator = new ConcreteMediator();
        ColleagueA colleagueA = new ColleagueA(mediator);
        ColleagueB colleagueB = new ColleagueB(mediator);
        mediator.setColleagueA(colleagueA);
        mediator.setColleagueB(colleagueB);

        colleagueA.send("Hello from A!");
        colleagueB.send("Hi from B!");
    }
}

This code demonstrates how two colleagues communicate through a mediator.

What are the benefits of using the Mediator pattern?

The Mediator pattern promotes loose coupling by keeping objects from referring to each other explicitly. It centralizes communication, making it easier to manage and modify interactions between objects.