22 行为模式 － 调停者（Mediator）模式

1.用意

调停者模式包装了一系列对象相互作用的方式，使得这些对象不必互相明显引用。从而使它们可以轻松散地耦合。当这些对象中的某些对象之间的相互作用发生改变时，不会立即影响到其他的一些对象之间的相互作用。从而保证这些相互作用可以彼此独立地变化。

2.类图

3.代码

/*
 * 抽象同事类
 */
public abstract class Colleague {
	private Mediator mediator;

	public Colleague(Mediator m) {
		mediator = m;
	}

	public Mediator getMediator() {
		return mediator;
	}

	public abstract void action();

	public void change() {
		mediator.colleagueChanged(this);
	}
}

/*
 * 具体同事类1
 */
public class Colleague1 extends Colleague{
	public Colleague1(Mediator m) {
		super(m);
	}
	public void action() {
		S.s("This is an action from Colleague 1");
	}

}

/*
 * 具体同事类2
 */
public class Colleague2 extends Colleague{
	public Colleague2(Mediator m) {
		super(m);
	}
	public void action() {
		S.s("This is an action from Colleague 2");
	}
}


/*
 * 抽象调停者
 */
public abstract class Mediator {
	public abstract void colleagueChanged(Colleague c);

	public static void main(String args[]) {
		ConcreteMediator mediator = new ConcreteMediator();
		mediator.createConcreteMediator();
		Colleague c1 = new Colleague1(mediator);
		Colleague c2 = new Colleague2(mediator);
		mediator.colleagueChanged(c1);
	}

}


/*
 * 具体调停者
 */
public class ConcreteMediator extends Mediator {
	private Colleague1 colleague1;
	private Colleague2 colleague2;

	public void colleagueChanged(Colleague c) {
		colleague1.action();
		colleague2.action();
	}

	public void createConcreteMediator() {
		colleague1 = new Colleague1(this);
		colleague2 = new Colleague2(this);
	}

	public Colleague1 getColleague1() {
		return colleague1;
	}

	public Colleague2 getColleague2() {
		return colleague2;
	}
}

 

z

1.用意

调停者模式包装了一系列对象相互作用的方式，使得这些对象不必互相明显引用。从而使它们可以轻松散地耦合。当这些对象中的某些对象之间的相互作用发生改变时，不会立即影响到其他的一些对象之间的相互作用。从而保证这些相互作用可以彼此独立地变化。

2.类图

3.代码

/*
 * 抽象同事类
 */
public abstract class Colleague {
	private Mediator mediator;

	public Colleague(Mediator m) {
		mediator = m;
	}

	public Mediator getMediator() {
		return mediator;
	}

	public abstract void action();

	public void change() {
		mediator.colleagueChanged(this);
	}
}

/*
 * 具体同事类1
 */
public class Colleague1 extends Colleague{
	public Colleague1(Mediator m) {
		super(m);
	}
	public void action() {
		S.s("This is an action from Colleague 1");
	}

}

/*
 * 具体同事类2
 */
public class Colleague2 extends Colleague{
	public Colleague2(Mediator m) {
		super(m);
	}
	public void action() {
		S.s("This is an action from Colleague 2");
	}
}


/*
 * 抽象调停者
 */
public abstract class Mediator {
	public abstract void colleagueChanged(Colleague c);

	public static void main(String args[]) {
		ConcreteMediator mediator = new ConcreteMediator();
		mediator.createConcreteMediator();
		Colleague c1 = new Colleague1(mediator);
		Colleague c2 = new Colleague2(mediator);
		mediator.colleagueChanged(c1);
	}

}


/*
 * 具体调停者
 */
public class ConcreteMediator extends Mediator {
	private Colleague1 colleague1;
	private Colleague2 colleague2;

	public void colleagueChanged(Colleague c) {
		colleague1.action();
		colleague2.action();
	}

	public void createConcreteMediator() {
		colleague1 = new Colleague1(this);
		colleague2 = new Colleague2(this);
	}

	public Colleague1 getColleague1() {
		return colleague1;
	}

	public Colleague2 getColleague2() {
		return colleague2;
	}
}

 

z

1.用意

调停者模式包装了一系列对象相互作用的方式，使得这些对象不必互相明显引用。从而使它们可以轻松散地耦合。当这些对象中的某些对象之间的相互作用发生改变时，不会立即影响到其他的一些对象之间的相互作用。从而保证这些相互作用可以彼此独立地变化。

2.类图

3.代码

/*
 * 抽象同事类
 */
public abstract class Colleague {
	private Mediator mediator;

	public Colleague(Mediator m) {
		mediator = m;
	}

	public Mediator getMediator() {
		return mediator;
	}

	public abstract void action();

	public void change() {
		mediator.colleagueChanged(this);
	}
}

/*
 * 具体同事类1
 */
public class Colleague1 extends Colleague{
	public Colleague1(Mediator m) {
		super(m);
	}
	public void action() {
		S.s("This is an action from Colleague 1");
	}

}

/*
 * 具体同事类2
 */
public class Colleague2 extends Colleague{
	public Colleague2(Mediator m) {
		super(m);
	}
	public void action() {
		S.s("This is an action from Colleague 2");
	}
}


/*
 * 抽象调停者
 */
public abstract class Mediator {
	public abstract void colleagueChanged(Colleague c);

	public static void main(String args[]) {
		ConcreteMediator mediator = new ConcreteMediator();
		mediator.createConcreteMediator();
		Colleague c1 = new Colleague1(mediator);
		Colleague c2 = new Colleague2(mediator);
		mediator.colleagueChanged(c1);
	}

}


/*
 * 具体调停者
 */
public class ConcreteMediator extends Mediator {
	private Colleague1 colleague1;
	private Colleague2 colleague2;

	public void colleagueChanged(Colleague c) {
		colleague1.action();
		colleague2.action();
	}

	public void createConcreteMediator() {
		colleague1 = new Colleague1(this);
		colleague2 = new Colleague2(this);
	}

	public Colleague1 getColleague1() {
		return colleague1;
	}

	public Colleague2 getColleague2() {
		return colleague2;
	}
}

 

z

1.用意

调停者模式包装了一系列对象相互作用的方式，使得这些对象不必互相明显引用。从而使它们可以轻松散地耦合。当这些对象中的某些对象之间的相互作用发生改变时，不会立即影响到其他的一些对象之间的相互作用。从而保证这些相互作用可以彼此独立地变化。

2.类图

3.代码

/*
 * 抽象同事类
 */
public abstract class Colleague {
	private Mediator mediator;

	public Colleague(Mediator m) {
		mediator = m;
	}

	public Mediator getMediator() {
		return mediator;
	}

	public abstract void action();

	public void change() {
		mediator.colleagueChanged(this);
	}
}

/*
 * 具体同事类1
 */
public class Colleague1 extends Colleague{
	public Colleague1(Mediator m) {
		super(m);
	}
	public void action() {
		S.s("This is an action from Colleague 1");
	}

}

/*
 * 具体同事类2
 */
public class Colleague2 extends Colleague{
	public Colleague2(Mediator m) {
		super(m);
	}
	public void action() {
		S.s("This is an action from Colleague 2");
	}
}


/*
 * 抽象调停者
 */
public abstract class Mediator {
	public abstract void colleagueChanged(Colleague c);

	public static void main(String args[]) {
		ConcreteMediator mediator = new ConcreteMediator();
		mediator.createConcreteMediator();
		Colleague c1 = new Colleague1(mediator);
		Colleague c2 = new Colleague2(mediator);
		mediator.colleagueChanged(c1);
	}

}


/*
 * 具体调停者
 */
public class ConcreteMediator extends Mediator {
	private Colleague1 colleague1;
	private Colleague2 colleague2;

	public void colleagueChanged(Colleague c) {
		colleague1.action();
		colleague2.action();
	}

	public void createConcreteMediator() {
		colleague1 = new Colleague1(this);
		colleague2 = new Colleague2(this);
	}

	public Colleague1 getColleague1() {
		return colleague1;
	}

	public Colleague2 getColleague2() {
		return colleague2;
	}
}

 

z

1.用意

调停者模式包装了一系列对象相互作用的方式，使得这些对象不必互相明显引用。从而使它们可以轻松散地耦合。当这些对象中的某些对象之间的相互作用发生改变时，不会立即影响到其他的一些对象之间的相互作用。从而保证这些相互作用可以彼此独立地变化。

2.类图

3.代码

/*
 * 抽象同事类
 */
public abstract class Colleague {
	private Mediator mediator;

	public Colleague(Mediator m) {
		mediator = m;
	}

	public Mediator getMediator() {
		return mediator;
	}

	public abstract void action();

	public void change() {
		mediator.colleagueChanged(this);
	}
}

/*
 * 具体同事类1
 */
public class Colleague1 extends Colleague{
	public Colleague1(Mediator m) {
		super(m);
	}
	public void action() {
		S.s("This is an action from Colleague 1");
	}

}

/*
 * 具体同事类2
 */
public class Colleague2 extends Colleague{
	public Colleague2(Mediator m) {
		super(m);
	}
	public void action() {
		S.s("This is an action from Colleague 2");
	}
}


/*
 * 抽象调停者
 */
public abstract class Mediator {
	public abstract void colleagueChanged(Colleague c);

	public static void main(String args[]) {
		ConcreteMediator mediator = new ConcreteMediator();
		mediator.createConcreteMediator();
		Colleague c1 = new Colleague1(mediator);
		Colleague c2 = new Colleague2(mediator);
		mediator.colleagueChanged(c1);
	}

}


/*
 * 具体调停者
 */
public class ConcreteMediator extends Mediator {
	private Colleague1 colleague1;
	private Colleague2 colleague2;

	public void colleagueChanged(Colleague c) {
		colleague1.action();
		colleague2.action();
	}

	public void createConcreteMediator() {
		colleague1 = new Colleague1(this);
		colleague2 = new Colleague2(this);
	}

	public Colleague1 getColleague1() {
		return colleague1;
	}

	public Colleague2 getColleague2() {
		return colleague2;
	}
}

 

z

1.用意

调停者模式包装了一系列对象相互作用的方式，使得这些对象不必互相明显引用。从而使它们可以轻松散地耦合。当这些对象中的某些对象之间的相互作用发生改变时，不会立即影响到其他的一些对象之间的相互作用。从而保证这些相互作用可以彼此独立地变化。

2.类图

3.代码

/*
 * 抽象同事类
 */
public abstract class Colleague {
	private Mediator mediator;

	public Colleague(Mediator m) {
		mediator = m;
	}

	public Mediator getMediator() {
		return mediator;
	}

	public abstract void action();

	public void change() {
		mediator.colleagueChanged(this);
	}
}

/*
 * 具体同事类1
 */
public class Colleague1 extends Colleague{
	public Colleague1(Mediator m) {
		super(m);
	}
	public void action() {
		S.s("This is an action from Colleague 1");
	}

}

/*
 * 具体同事类2
 */
public class Colleague2 extends Colleague{
	public Colleague2(Mediator m) {
		super(m);
	}
	public void action() {
		S.s("This is an action from Colleague 2");
	}
}


/*
 * 抽象调停者
 */
public abstract class Mediator {
	public abstract void colleagueChanged(Colleague c);

	public static void main(String args[]) {
		ConcreteMediator mediator = new ConcreteMediator();
		mediator.createConcreteMediator();
		Colleague c1 = new Colleague1(mediator);
		Colleague c2 = new Colleague2(mediator);
		mediator.colleagueChanged(c1);
	}

}


/*
 * 具体调停者
 */
public class ConcreteMediator extends Mediator {
	private Colleague1 colleague1;
	private Colleague2 colleague2;

	public void colleagueChanged(Colleague c) {
		colleague1.action();
		colleague2.action();
	}

	public void createConcreteMediator() {
		colleague1 = new Colleague1(this);
		colleague2 = new Colleague2(this);
	}

	public Colleague1 getColleague1() {
		return colleague1;
	}

	public Colleague2 getColleague2() {
		return colleague2;
	}
}

 

z