Java Implementation

Let's Implement above Traffic Light Signal Mediator Example using Java.

import java.util.HashSet;


public class MediatorDesignPatternDemo {

	public static void main(String[] args) {
		
		LightMediator lightMediator = new LightMediator();
		Light red = new Light("Red", lightMediator);
		Light green = new Light("Green", lightMediator);
		Light yellow = new Light("Yellow", lightMediator);
		
		red.turnON();
		green.turnON();
		yellow.turnON();
	}

}

/**
 * 
 * When any light turns ON in traffic Signal, 
 * Light Mediator turns OFF other lights.
 *
 */
class LightMediator {

	// Using Hashset to achieve uniqueness in light color.
	HashSet<Light> trafficSignal = new HashSet<>();

	/**
	 * register passed light object in LightMediator
	 * It is being called by constructor of Light class.
	 * We can also explicitly call this method.
	 */
	public void registerLight(Light light) {
		trafficSignal.add(light);
	}
	
	/**
	 * unregisters light from LightMediator
	 */
	public void unRegisterLight(Light light) {
		trafficSignal.remove(light);
	}

	/**
	 * Turns off all the lights other than 
	 * passed light Object
	 */
	void turnOffAllOtherLights(Light light) {
		for (Light l : trafficSignal) {
			if (!(l.equals(light))) {
				l.turnOFF();
			}
		}
		System.out.println("------------------------------");
	}

	/**
	 * When any light turns ON, it calls this method
	 * to notify mediator. Light mediator will turn OFF 
	 * all other light by calling turnOffAllOtherLights(light)
	 * method
	 */
	public void notifyMediator(Light light) {
		turnOffAllOtherLights(light);
	}
}

/**
 * Represent light in traffic signal i.e. Red, Green or Yellow light
 */
class Light {

	/**
	 * represents the turn ON and OFF state of light
	 */
	enum State {
		ON, OFF
	}

	private String color;
	private State currentState;
	private LightMediator LightMediator;

	/**
	 * Creates Light object and register it to LightMediator
	 */
	Light(String color, LightMediator LightMediator) {
		this.color = color;
		this.LightMediator = LightMediator;
		LightMediator.registerLight(this);
	}

	/**
	 * Turns ON the light and notify mediator for the same
	 */
	void turnON() {
		currentState = State.ON;
		System.out.printf("%s is turned %s \n", this, currentState.ON);
		LightMediator.notifyMediator(this);
	}

	/**
	 * Turns OFF the light
	 */
	void turnOFF() {
		currentState = State.OFF;
		System.out.printf("%s is turned %s \n", this, currentState.OFF);
	}

	/**
	 *  It is  generated using its String property 
	 *  color's inbuilt hashcode() method
	 */
	@Override
	public int hashCode() {
		return color.hashCode();
	}

	/**
	 *  Uses its String property color's inbuilt hashcode() method
	 */
	@Override
	public boolean equals(Object obj) {
		Light light = (Light) obj;
		return color.equals(light.color);
	}

	/**
	 * returns light color
	 */
	@Override
	public String toString() {
		return color;
	}
}

Output:

Red is turned ON 
Yellow is turned OFF 
Green is turned OFF 
------------------------------
Green is turned ON 
Red is turned OFF 
Yellow is turned OFF 
------------------------------
Yellow is turned ON 
Red is turned OFF 
Green is turned OFF 
------------------------------

Download Complete Java Program »

Mediator Design Pattern VS Observer Design Pattern

In the original book that coined the terms Observer and Mediator, Design Patterns, Elements of Reusable Object-Oriented Software it says that the Mediator pattern can be implemented by using the observer pattern.

A comparison between the mediator pattern and the Observer Design Pattern shows some similarities and some clear differences.

Similarity : Both patterns facilitates the communication between objects, and both decouples the link between the sender and the receiver.

Difference : The main difference is that in the Mediator Design Pattern there is the notion of the participants and they communicate with each other using the mediator as a central hub, whereas in the Observer Design Pattern, there is a clear distinction between the sender and the receiver, and the receiver merely listens to the changes in the sender.

For Example:

Observer Design Pattern: Class A, can have zero or more observers of type O registered with it. When something in A is changed it notifies all of the observers.

Mediator Design Pattern: You have some number of instances of class X (or maybe even several different types:X, Y & Z), and they wish to communicate with each other (but you don't want each to have explicit references to each other), so you create a mediator class M. Each instance of X has a reference to a shared instance of M, through which it can communicate with the other instances of X (or X, Y and Z).

Existing Implementation in JDK

• java.util.Timer (all scheduleXXX() methods)
• java.util.concurrent.Executor#execute()
• java.util.concurrent.ExecutorService (the invokeXXX() and submit() methods)
• java.util.concurrent.ScheduledExecutorService (all scheduleXXX() methods)
• java.lang.reflect.Method#invoke()

Note : Read our article Threadpool using Executor Framework to know more about above mentioned ExecutorService class.