The Mediator Pattern defines an object that encapsulates how a set of objects interact. It promotes loose coupling by keeping objects from referring to each other explicitly, and it lets you vary their interaction independently.

Key Concepts

• Mediator: Interface for communicating with Colleague objects
• Concrete Mediator: Implements cooperative behavior by coordinating Colleague objects
• Colleague: Objects that communicate with each other through the Mediator
• Loose Coupling: Colleagues don't communicate directly with each other

Basic Implementation

Example 1: Basic Mediator Pattern

import java.util.*; // Mediator interface interface Mediator { void sendMessage(String message, Colleague colleague); void addColleague(Colleague colleague); } // Concrete mediator class ConcreteMediator implements Mediator { private List<Colleague> colleagues = new ArrayList<>(); @Override public void addColleague(Colleague colleague) { colleagues.add(colleague); colleague.setMediator(this); } @Override public void sendMessage(String message, Colleague sender) { for (Colleague colleague : colleagues) { // Don't send the message back to the sender if (colleague != sender) { colleague.receiveMessage(message); } } } // Advanced mediation - send to specific colleague type public void sendToType(String message, Colleague sender, String type) { for (Colleague colleague : colleagues) { if (colleague != sender && colleague.getType().equals(type)) { colleague.receiveMessage(message); } } } } // Abstract colleague abstract class Colleague { protected Mediator mediator; protected String name; protected String type; public Colleague(String name, String type) { this.name = name; this.type = type; } public void setMediator(Mediator mediator) { this.mediator = mediator; } public abstract void sendMessage(String message); public abstract void receiveMessage(String message); public String getName() { return name; } public String getType() { return type; } } // Concrete colleagues class ConcreteColleague extends Colleague { public ConcreteColleague(String name, String type) { super(name, type); } @Override public void sendMessage(String message) { System.out.println(name + " [" + type + "] sends: " + message); mediator.sendMessage(message, this); } @Override public void receiveMessage(String message) { System.out.println(name + " [" + type + "] receives: " + message); } } // Demo public class BasicMediatorDemo { public static void main(String[] args) { Mediator mediator = new ConcreteMediator(); Colleague alice = new ConcreteColleague("Alice", "User"); Colleague bob = new ConcreteColleague("Bob", "User"); Colleague admin = new ConcreteColleague("Admin", "Administrator"); mediator.addColleague(alice); mediator.addColleague(bob); mediator.addColleague(admin); System.out.println("=== Basic Communication ==="); alice.sendMessage("Hello everyone!"); System.out.println(); bob.sendMessage("Hi Alice!"); System.out.println(); admin.sendMessage("System maintenance at 2 AM"); } }

Real-World Example: Chat Room System

Example 2: Chat Room Mediator

import java.util.*; import java.time.LocalDateTime; import java.time.format.DateTimeFormatter; // Message class class Message { private String content; private String sender; private LocalDateTime timestamp; private MessageType type; public Message(String content, String sender, MessageType type) { this.content = content; this.sender = sender; this.timestamp = LocalDateTime.now(); this.type = type; } // Getters public String getContent() { return content; } public String getSender() { return sender; } public LocalDateTime getTimestamp() { return timestamp; } public MessageType getType() { return type; } @Override public String toString() { DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm:ss"); return "[" + timestamp.format(formatter) + "] " + sender + ": " + content; } } enum MessageType { TEXT, IMAGE, FILE, SYSTEM } // User roles enum UserRole { REGULAR, MODERATOR, ADMINISTRATOR } // Chat mediator interface interface ChatMediator { void sendMessage(Message message, User user); void addUser(User user); void removeUser(User user); void createRoom(String roomName); void joinRoom(User user, String roomName); void leaveRoom(User user, String roomName); } // Concrete chat mediator class ChatRoomMediator implements ChatMediator { private Map<String, List<User>> rooms = new HashMap<>(); private List<User> allUsers = new ArrayList<>(); public ChatRoomMediator() { // Create default room rooms.put("general", new ArrayList<>()); } @Override public void addUser(User user) { allUsers.add(user); joinRoom(user, "general"); // Auto-join general room System.out.println("User " + user.getName() + " joined the chat"); } @Override public void removeUser(User user) { allUsers.remove(user); // Remove user from all rooms for (List<User> roomUsers : rooms.values()) { roomUsers.remove(user); } System.out.println("User " + user.getName() + " left the chat"); } @Override public void createRoom(String roomName) { if (!rooms.containsKey(roomName)) { rooms.put(roomName, new ArrayList<>()); System.out.println("Room '" + roomName + "' created"); // Notify all users about new room Message systemMessage = new Message( "New room '" + roomName + "' has been created", "System", MessageType.SYSTEM ); broadcastMessage(systemMessage, null); } } @Override public void joinRoom(User user, String roomName) { if (rooms.containsKey(roomName)) { rooms.get(roomName).add(user); user.setCurrentRoom(roomName); Message joinMessage = new Message( user.getName() + " joined the room", "System", MessageType.SYSTEM ); sendToRoom(joinMessage, user, roomName); } } @Override public void leaveRoom(User user, String roomName) { if (rooms.containsKey(roomName)) { rooms.get(roomName).remove(user); Message leaveMessage = new Message( user.getName() + " left the room", "System", MessageType.SYSTEM ); sendToRoom(leaveMessage, user, roomName); // Auto-join general room if leaving current room if (roomName.equals(user.getCurrentRoom())) { joinRoom(user, "general"); } } } @Override public void sendMessage(Message message, User sender) { if (sender.getCurrentRoom() != null) { sendToRoom(message, sender, sender.getCurrentRoom()); } } private void sendToRoom(Message message, User sender, String roomName) { List<User> roomUsers = rooms.get(roomName); if (roomUsers != null) { for (User user : roomUsers) { if (user != sender) { // Don't send to self user.receiveMessage(message); } } } } private void broadcastMessage(Message message, User sender) { for (User user : allUsers) { if (user != sender) { user.receiveMessage(message); } } } // Admin methods public void broadcastToAll(Message message) { broadcastMessage(message, null); } public List<String> getRoomList() { return new ArrayList<>(rooms.keySet()); } public List<String> getUsersInRoom(String roomName) { List<String> userNames = new ArrayList<>(); if (rooms.containsKey(roomName)) { for (User user : rooms.get(roomName)) { userNames.add(user.getName() + " (" + user.getRole() + ")"); } } return userNames; } } // User class (Colleague) abstract class User { protected ChatMediator mediator; protected String name; protected UserRole role; protected String currentRoom; public User(String name, UserRole role) { this.name = name; this.role = role; } public void setMediator(ChatMediator mediator) { this.mediator = mediator; } public void setCurrentRoom(String roomName) { this.currentRoom = roomName; } public abstract void sendMessage(String content, MessageType type); public abstract void receiveMessage(Message message); // Getters public String getName() { return name; } public UserRole getRole() { return role; } public String getCurrentRoom() { return currentRoom; } } // Concrete user implementations class RegularUser extends User { public RegularUser(String name) { super(name, UserRole.REGULAR); } @Override public void sendMessage(String content, MessageType type) { Message message = new Message(content, name, type); System.out.println("[" + currentRoom + "] " + message); mediator.sendMessage(message, this); } @Override public void receiveMessage(Message message) { System.out.println("[" + currentRoom + "] " + name + " received: " + message); } public void joinRoom(String roomName) { mediator.joinRoom(this, roomName); } public void leaveRoom(String roomName) { mediator.leaveRoom(this, roomName); } } class ModeratorUser extends RegularUser { public ModeratorUser(String name) { super(name); } public void createRoom(String roomName) { ((ChatRoomMediator) mediator).createRoom(roomName); } public void listUsersInRoom(String roomName) { List<String> users = ((ChatRoomMediator) mediator).getUsersInRoom(roomName); System.out.println("Users in room '" + roomName + "': " + users); } } class AdministratorUser extends ModeratorUser { public AdministratorUser(String name) { super(name); } public void broadcastToAll(String message) { Message systemMessage = new Message(message, "Admin Broadcast", MessageType.SYSTEM); ((ChatRoomMediator) mediator).broadcastToAll(systemMessage); System.out.println("Admin broadcast: " + message); } } // Demo public class ChatRoomDemo { public static void main(String[] args) { ChatMediator chatMediator = new ChatRoomMediator(); // Create users RegularUser alice = new RegularUser("Alice"); RegularUser bob = new RegularUser("Bob"); ModeratorUser charlie = new ModeratorUser("Charlie"); AdministratorUser diana = new AdministratorUser("Diana"); // Register users with mediator chatMediator.addUser(alice); chatMediator.addUser(bob); chatMediator.addUser(charlie); chatMediator.addUser(diana); System.out.println("\n=== Chat Room Demo ==="); // Regular chat alice.sendMessage("Hello everyone!", MessageType.TEXT); bob.sendMessage("Hi Alice! How are you?", MessageType.TEXT); // Create and join new room charlie.createRoom("programming"); alice.joinRoom("programming"); bob.joinRoom("programming"); charlie.joinRoom("programming"); System.out.println(); alice.sendMessage("Anyone working on Java projects?", MessageType.TEXT); bob.sendMessage("Yes, I'm learning design patterns!", MessageType.TEXT); // Admin broadcast System.out.println(); diana.broadcastToAll("Server maintenance in 30 minutes!"); // List users in room System.out.println(); charlie.listUsersInRoom("programming"); // Leave room System.out.println(); alice.leaveRoom("programming"); alice.sendMessage("Back in general chat!", MessageType.TEXT); } }

Advanced Example: Air Traffic Control System

Example 3: Air Traffic Control Mediator

import java.util.*; // Aircraft types enum AircraftType { COMMERCIAL, CARGO, PRIVATE, MILITARY } // Aircraft status enum AircraftStatus { ON_STAND, TAXIING, WAITING, TAKEOFF, LANDING, IN_FLIGHT } // Position class class Position { private int x; private int y; private int altitude; public Position(int x, int y, int altitude) { this.x = x; this.y = y; this.altitude = altitude; } // Getters and setters public int getX() { return x; } public void setX(int x) { this.x = x; } public int getY() { return y; } public void setY(int y) { this.y = y; } public int getAltitude() { return altitude; } public void setAltitude(int altitude) { this.altitude = altitude; } public double distanceTo(Position other) { int dx = x - other.x; int dy = y - other.y; int dz = altitude - other.altitude; return Math.sqrt(dx * dx + dy * dy + dz * dz); } @Override public String toString() { return "(" + x + ", " + y + ")@" + altitude + "ft"; } } // Air Traffic Control Mediator interface ATCMediator { void registerAircraft(Aircraft aircraft); void unregisterAircraft(Aircraft aircraft); void requestTakeoff(Aircraft aircraft, String runway); void requestLanding(Aircraft aircraft, String runway); void reportPosition(Aircraft aircraft, Position position); void sendWarning(String message, Aircraft recipient); boolean isRunwayAvailable(String runway); List<Aircraft> getNearbyAircraft(Aircraft aircraft, double radius); } // Concrete ATC Mediator class ControlTower implements ATCMediator { private List<Aircraft> aircraftList = new ArrayList<>(); private Set<String> occupiedRunways = new HashSet<>(); private Map<String, List<String>> communicationLog = new HashMap<>(); @Override public void registerAircraft(Aircraft aircraft) { aircraftList.add(aircraft); communicationLog.put(aircraft.getCallSign(), new ArrayList<>()); logCommunication("Control Tower", aircraft.getCallSign(), "Aircraft registered with control tower"); System.out.println("ATC: " + aircraft.getCallSign() + " registered"); } @Override public void unregisterAircraft(Aircraft aircraft) { aircraftList.remove(aircraft); communicationLog.remove(aircraft.getCallSign()); System.out.println("ATC: " + aircraft.getCallSign() + " unregistered"); } @Override public void requestTakeoff(Aircraft aircraft, String runway) { if (isRunwayAvailable(runway)) { occupiedRunways.add(runway); aircraft.setStatus(AircraftStatus.TAKEOFF); logCommunication(aircraft.getCallSign(), "Control Tower", "Request takeoff on runway " + runway + " - APPROVED"); System.out.println("ATC: " + aircraft.getCallSign() + " cleared for takeoff on " + runway); } else { logCommunication(aircraft.getCallSign(), "Control Tower", "Request takeoff on runway " + runway + " - DENIED"); System.out.println("ATC: " + aircraft.getCallSign() + " hold position, runway " + runway + " occupied"); } } @Override public void requestLanding(Aircraft aircraft, String runway) { if (isRunwayAvailable(runway)) { occupiedRunways.add(runway); aircraft.setStatus(AircraftStatus.LANDING); logCommunication(aircraft.getCallSign(), "Control Tower", "Request landing on runway " + runway + " - APPROVED"); System.out.println("ATC: " + aircraft.getCallSign() + " cleared to land on " + runway); } else { logCommunication(aircraft.getCallSign(), "Control Tower", "Request landing on runway " + runway + " - HOLD"); System.out.println("ATC: " + aircraft.getCallSign() + " go around, runway " + runway + " occupied"); } } @Override public void reportPosition(Aircraft aircraft, Position position) { aircraft.setPosition(position); logCommunication(aircraft.getCallSign(), "Control Tower", "Position report: " + position); // Check for potential conflicts checkForConflicts(aircraft); } @Override public void sendWarning(String message, Aircraft recipient) { logCommunication("Control Tower", recipient.getCallSign(), "WARNING: " + message); recipient.receiveWarning(message); } @Override public boolean isRunwayAvailable(String runway) { return !occupiedRunways.contains(runway); } @Override public List<Aircraft> getNearbyAircraft(Aircraft aircraft, double radius) { List<Aircraft> nearby = new ArrayList<>(); Position pos = aircraft.getPosition(); for (Aircraft other : aircraftList) { if (other != aircraft && pos != null && other.getPosition() != null) { double distance = pos.distanceTo(other.getPosition()); if (distance <= radius) { nearby.add(other); } } } return nearby; } private void checkForConflicts(Aircraft aircraft) { List<Aircraft> nearby = getNearbyAircraft(aircraft, 5.0); // 5 unit radius if (!nearby.isEmpty()) { String warning = "Traffic alert: " + nearby.size() + " aircraft nearby"; sendWarning(warning, aircraft); for (Aircraft other : nearby) { sendWarning("Maintain separation from " + other.getCallSign(), aircraft); } } } public void releaseRunway(String runway) { occupiedRunways.remove(runway); System.out.println("ATC: Runway " + runway + " now available"); } public void printCommunicationLog(String callSign) { System.out.println("\nCommunication log for " + callSign + ":"); List<String> logs = communicationLog.get(callSign); if (logs != null) { for (String log : logs) { System.out.println(" " + log); } } } private void logCommunication(String from, String to, String message) { String logEntry = from + " -> " + to + ": " + message; communicationLog.get(to).add(logEntry); } } // Aircraft class (Colleague) abstract class Aircraft { protected ATCMediator mediator; protected String callSign; protected AircraftType type; protected AircraftStatus status; protected Position position; public Aircraft(String callSign, AircraftType type) { this.callSign = callSign; this.type = type; this.status = AircraftStatus.ON_STAND; } public void setMediator(ATCMediator mediator) { this.mediator = mediator; mediator.registerAircraft(this); } public abstract void requestTakeoff(String runway); public abstract void requestLanding(String runway); public abstract void reportPosition(Position position); public abstract void receiveWarning(String warning); // Getters and setters public String getCallSign() { return callSign; } public AircraftType getType() { return type; } public AircraftStatus getStatus() { return status; } public void setStatus(AircraftStatus status) { this.status = status; } public Position getPosition() { return position; } public void setPosition(Position position) { this.position = position; } } // Concrete aircraft implementations class CommercialAircraft extends Aircraft { private String airline; private int passengerCount; public CommercialAircraft(String callSign, String airline, int passengerCount) { super(callSign, AircraftType.COMMERCIAL); this.airline = airline; this.passengerCount = passengerCount; } @Override public void requestTakeoff(String runway) { System.out.println(callSign + " (" + airline + "): Requesting takeoff on runway " + runway); mediator.requestTakeoff(this, runway); } @Override public void requestLanding(String runway) { System.out.println(callSign + " (" + airline + "): Requesting landing on runway " + runway); mediator.requestLanding(this, runway); } @Override public void reportPosition(Position position) { System.out.println(callSign + ": Position report - " + position); mediator.reportPosition(this, position); } @Override public void receiveWarning(String warning) { System.out.println("⚠️ " + callSign + " ALERT: " + warning); } public void boardPassengers() { System.out.println(callSign + ": Boarding " + passengerCount + " passengers"); } public void disembarkPassengers() { System.out.println(callSign + ": Disembarking " + passengerCount + " passengers"); } } class CargoAircraft extends Aircraft { private double cargoWeight; private String cargoType; public CargoAircraft(String callSign, double cargoWeight, String cargoType) { super(callSign, AircraftType.CARGO); this.cargoWeight = cargoWeight; this.cargoType = cargoType; } @Override public void requestTakeoff(String runway) { System.out.println(callSign + " (Cargo): Requesting takeoff on runway " + runway); mediator.requestTakeoff(this, runway); } @Override public void requestLanding(String runway) { System.out.println(callSign + " (Cargo): Requesting landing on runway " + runway); mediator.requestLanding(this, runway); } @Override public void reportPosition(Position position) { System.out.println(callSign + ": Position report - " + position); mediator.reportPosition(this, position); } @Override public void receiveWarning(String warning) { System.out.println("⚠️ " + callSign + " ALERT: " + warning); } public void loadCargo() { System.out.println(callSign + ": Loading " + cargoWeight + " tons of " + cargoType); } public void unloadCargo() { System.out.println(callSign + ": Unloading " + cargoWeight + " tons of " + cargoType); } } // Demo public class ATCDemo { public static void main(String[] args) { ATCMediator controlTower = new ControlTower(); // Create aircraft CommercialAircraft flight123 = new CommercialAircraft("UAL123", "United Airlines", 180); CommercialAircraft flight456 = new CommercialAircraft("DAL456", "Delta Airlines", 220); CargoAircraft cargo789 = new CargoAircraft("FED789", 45.5, "Electronics"); // Register with control tower flight123.setMediator(controlTower); flight456.setMediator(controlTower); cargo789.setMediator(controlTower); System.out.println("=== Air Traffic Control Demo ===\n"); // Simulate airport operations flight123.boardPassengers(); flight123.requestTakeoff("09L"); cargo789.loadCargo(); cargo789.requestTakeoff("09R"); // Report positions (simulate potential conflict) System.out.println("\n=== In-flight Operations ==="); flight123.reportPosition(new Position(10, 15, 10000)); flight456.reportPosition(new Position(12, 18, 10050)); // Close to flight123 cargo789.reportPosition(new Position(50, 60, 8000)); // Landing sequence System.out.println("\n=== Landing Operations ==="); flight456.requestLanding("09L"); flight123.requestLanding("09L"); // Should be denied initially // Release runway and try again ((ControlTower) controlTower).releaseRunway("09L"); flight123.requestLanding("09L"); // Print communication logs System.out.println("\n=== Communication Logs ==="); ((ControlTower) controlTower).printCommunicationLog("UAL123"); ((ControlTower) controlTower).printCommunicationLog("DAL456"); } }

GUI Application Example

Example 4: UI Component Mediator

import java.util.*; import javax.swing.*; import java.awt.*; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; // Mediator interface for UI components interface UIMediator { void componentChanged(UIComponent component); void registerComponent(UIComponent component); } // Abstract UI component abstract class UIComponent { protected UIMediator mediator; protected String name; protected boolean enabled = true; protected boolean visible = true; public UIComponent(String name) { this.name = name; } public void setMediator(UIMediator mediator) { this.mediator = mediator; mediator.registerComponent(this); } public abstract JComponent getJComponent(); public void setEnabled(boolean enabled) { this.enabled = enabled; getJComponent().setEnabled(enabled); } public void setVisible(boolean visible) { this.visible = visible; getJComponent().setVisible(visible); } public String getName() { return name; } public boolean isEnabled() { return enabled; } public boolean isVisible() { return visible; } protected void notifyMediator() { if (mediator != null) { mediator.componentChanged(this); } } } // Concrete UI components class TextFieldComponent extends UIComponent { private JTextField textField; public TextFieldComponent(String name, int columns) { super(name); this.textField = new JTextField(columns); this.textField.setName(name); this.textField.getDocument().addDocumentListener(new javax.swing.event.DocumentListener() { public void insertUpdate(javax.swing.event.DocumentEvent e) { notifyMediator(); } public void removeUpdate(javax.swing.event.DocumentEvent e) { notifyMediator(); } public void changedUpdate(javax.swing.event.DocumentEvent e) { notifyMediator(); } }); } @Override public JComponent getJComponent() { return textField; } public String getText() { return textField.getText(); } public void setText(String text) { textField.setText(text); } } class ButtonComponent extends UIComponent { private JButton button; public ButtonComponent(String name, String text) { super(name); this.button = new JButton(text); this.button.setName(name); this.button.addActionListener(new ActionListener() { @Override public void actionPerformed(ActionEvent e) { notifyMediator(); } }); } @Override public JComponent getJComponent() { return button; } public void setText(String text) { button.setText(text); } } class CheckBoxComponent extends UIComponent { private JCheckBox checkBox; public CheckBoxComponent(String name, String text) { super(name); this.checkBox = new JCheckBox(text); this.checkBox.setName(name); this.checkBox.addActionListener(new ActionListener() { @Override public void actionPerformed(ActionEvent e) { notifyMediator(); } }); } @Override public JComponent getJComponent() { return checkBox; } public boolean isSelected() { return checkBox.isSelected(); } public void setSelected(boolean selected) { checkBox.setSelected(selected); } } class LabelComponent extends UIComponent { private JLabel label; public LabelComponent(String name, String text) { super(name); this.label = new JLabel(text); this.label.setName(name); } @Override public JComponent getJComponent() { return label; } public void setText(String text) { label.setText(text); } } // Concrete mediator for login form class LoginFormMediator implements UIMediator { private Map<String, UIComponent> components = new HashMap<>(); private int loginAttempts = 0; private static final int MAX_ATTEMPTS = 3; @Override public void registerComponent(UIComponent component) { components.put(component.getName(), component); } @Override public void componentChanged(UIComponent component) { String componentName = component.getName(); switch (componentName) { case "usernameField": validateForm(); break; case "passwordField": validateForm(); break; case "rememberMeCheckbox": handleRememberMe(); break; case "loginButton": handleLogin(); break; case "clearButton": handleClear(); break; } } private void validateForm() { TextFieldComponent usernameField = (TextFieldComponent) components.get("usernameField"); TextFieldComponent passwordField = (TextFieldComponent) components.get("passwordField"); ButtonComponent loginButton = (ButtonComponent) components.get("loginButton"); boolean isValid = !usernameField.getText().trim().isEmpty() && !passwordField.getText().trim().isEmpty(); loginButton.setEnabled(isValid); } private void handleRememberMe() { CheckBoxComponent rememberMe = (CheckBoxComponent) components.get("rememberMeCheckbox"); LabelComponent statusLabel = (LabelComponent) components.get("statusLabel"); if (rememberMe.isSelected()) { statusLabel.setText("Login will be remembered"); } else { statusLabel.setText(""); } } private void handleLogin() { TextFieldComponent usernameField = (TextFieldComponent) components.get("usernameField"); TextFieldComponent passwordField = (TextFieldComponent) components.get("passwordField"); LabelComponent statusLabel = (LabelComponent) components.get("statusLabel"); String username = usernameField.getText(); String password = passwordField.getText(); loginAttempts++; if ("admin".equals(username) && "password".equals(password)) { statusLabel.setText("Login successful! Attempts: " + loginAttempts); disableForm(); } else { statusLabel.setText("Login failed! Attempts: " + loginAttempts + "/" + MAX_ATTEMPTS); if (loginAttempts >= MAX_ATTEMPTS) { statusLabel.setText("Too many failed attempts! Form disabled."); disableForm(); } } } private void handleClear() { TextFieldComponent usernameField = (TextFieldComponent) components.get("usernameField"); TextFieldComponent passwordField = (TextFieldComponent) components.get("passwordField"); CheckBoxComponent rememberMe = (CheckBoxComponent) components.get("rememberMeCheckbox"); LabelComponent statusLabel = (LabelComponent) components.get("statusLabel"); usernameField.setText(""); passwordField.setText(""); rememberMe.setSelected(false); statusLabel.setText("Form cleared"); validateForm(); } private void disableForm() { components.get("usernameField").setEnabled(false); components.get("passwordField").setEnabled(false); components.get("loginButton").setEnabled(false); components.get("rememberMeCheckbox").setEnabled(false); components.get("clearButton").setEnabled(false); } } // Demo GUI Application public class UIMediatorDemo extends JFrame { private UIMediator mediator; public UIMediatorDemo() { mediator = new LoginFormMediator(); initializeUI(); } private void initializeUI() { setTitle("Mediator Pattern - Login Form"); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setLayout(new GridBagLayout()); GridBagConstraints gbc = new GridBagConstraints(); gbc.insets = new Insets(5, 5, 5, 5); gbc.fill = GridBagConstraints.HORIZONTAL; // Create components LabelComponent usernameLabel = new LabelComponent("usernameLabel", "Username:"); TextFieldComponent usernameField = new TextFieldComponent("usernameField", 15); LabelComponent passwordLabel = new LabelComponent("passwordLabel", "Password:"); TextFieldComponent passwordField = new TextFieldComponent("passwordField", 15); passwordField.getJComponent().setToolTipText("Enter 'admin' and 'password'"); CheckBoxComponent rememberMeCheckbox = new CheckBoxComponent("rememberMeCheckbox", "Remember me"); ButtonComponent loginButton = new ButtonComponent("loginButton", "Login"); ButtonComponent clearButton = new ButtonComponent("clearButton", "Clear"); LabelComponent statusLabel = new LabelComponent("statusLabel", "Please enter credentials"); // Register components with mediator usernameField.setMediator(mediator); passwordField.setMediator(mediator); rememberMeCheckbox.setMediator(mediator); loginButton.setMediator(mediator); clearButton.setMediator(mediator); statusLabel.setMediator(mediator); // Add components to frame gbc.gridx = 0; gbc.gridy = 0; add(usernameLabel.getJComponent(), gbc); gbc.gridx = 1; gbc.gridy = 0; add(usernameField.getJComponent(), gbc); gbc.gridx = 0; gbc.gridy = 1; add(passwordLabel.getJComponent(), gbc); gbc.gridx = 1; gbc.gridy = 1; add(passwordField.getJComponent(), gbc); gbc.gridx = 0; gbc.gridy = 2; gbc.gridwidth = 2; add(rememberMeCheckbox.getJComponent(), gbc); gbc.gridx = 0; gbc.gridy = 3; gbc.gridwidth = 1; add(loginButton.getJComponent(), gbc); gbc.gridx = 1; gbc.gridy = 3; add(clearButton.getJComponent(), gbc); gbc.gridx = 0; gbc.gridy = 4; gbc.gridwidth = 2; add(statusLabel.getJComponent(), gbc); pack(); setLocationRelativeTo(null); } public static void main(String[] args) { SwingUtilities.invokeLater(new Runnable() { @Override public void run() { new UIMediatorDemo().setVisible(true); } }); } }

Best Practices and Considerations

When to Use Mediator Pattern:

• Complex object interactions: When objects have complex communication logic
• Reusability: When you want to reuse individual components easily
• Decoupling: When you want to reduce dependencies between objects
• Centralized control: When you need centralized control over interactions

Benefits:

• Reduces coupling: Objects don't reference each other directly
• Simplifies object protocols: Replaces many-to-many with one-to-many
• Centralizes control: Interaction logic is in one place
• Improves reusability: Components can be reused more easily

Drawbacks:

• Mediator can become complex: Can become a "god object"
• Single point of failure: Mediator failure affects entire system
• Performance overhead: Additional layer of indirection

Implementation Tips:

1. Define clear mediator interface with well-defined communication methods
2. Use abstract colleague classes to provide common functionality
3. Consider using events for more complex communication scenarios
4. Keep mediator focused on coordination, not business logic
5. Use dependency injection to provide mediator instances

The Mediator Pattern is particularly useful in GUI applications, chat systems, air traffic control, and any scenario where multiple objects need to communicate in a coordinated way without being tightly coupled.