Aircraft Control System Scenario

Consider an aircraft control system involving airplanes, control towers, and ground services.

class Airplane {
    private ControlTower tower;
    private GroundService service;

    public Airplane(ControlTower t, GroundService g) {
        this.tower = t;
        this.service = g;
    }

    public void requestLanding() {
        tower.approveLanding();
    }

    public void requestService() {
        service.handleBaggage();
    }
}

class ControlTower { /* ... */ }
class GroundService { /* ... */ }

Mediator Pattern Implementation

The Mediator Pattern reduces direct communication between objects by introducing a mediator object that handles interactions.

Core Components

1. Mediator Interface: Defines communication protocol
2. Concrete Mediator: Implements coordination logic
3. Colleague Objects: Components that communicate through mediator

Implementation Example

interface TrafficCoordinator {
    void transmit(String msg, AircraftParticipant sender);
}

class ATCMediator implements TrafficCoordinator {
    private List<AircraftParticipant> participants = new ArrayList<>();

    public void addParticipant(AircraftParticipant p) {
        participants.add(p);
    }

    @Override
    public void transmit(String msg, AircraftParticipant sender) {
        for (AircraftParticipant p : participants) {
            if (p != sender) {
                p.accept(msg);
            }
        }
    }
}

interface AircraftParticipant {
    void send(String msg);
    void accept(String msg);
}

class Flight implements AircraftParticipant {
    private String callsign;
    private TrafficCoordinator coordinator;

    public Flight(String id, TrafficCoordinator c) {
        this.callsign = id;
        this.coordinator = c;
    }

    @Override
    public void send(String msg) {
        System.out.println(callsign + " transmitting: " + msg);
        coordinator.transmit(msg, this);
    }

    @Override
    public void accept(String msg) {
        System.out.println(callsign + " received: " + msg);
    }
}

Practical Application

public class ControlSystem {
    public static void main(String[] args) {
        TrafficCoordinator atc = new ATCMediator();
        
        AircraftParticipant flight123 = new Flight("FL123", atc);
        AircraftParticipant tower = new Tower("MAIN_TOWER", atc);
        AircraftParticipant service = new ServiceTeam("GROUND_1", atc);
        
        atc.addParticipant(flight123);
        atc.addParticipant(tower);
        atc.addParticipant(service);
        
        flight123.send("Requesting landing clearance");
        tower.send("Cleared to land runway 27L");
        service.send("Standby for baggage handling");
    }
}

Common Use Cases

1. Complex GUI component interactions
2. Multi-user chat systems
3. Air traffic control coordination
4. Distributed system communication
5. Event handling systems