设计模式第九次作业—中介者模式、桥接模式

Mediator模式

**将对象间的交互和通信封装在一个类中，
*各个对象间的通信不必显式去声明和引用，大大降低了系统的复杂性能（了解一个对象总比深入熟悉n个对象妥好）。
*Mediator模式还带来了系统对象间的松耦合。
*通过中介者模式，可以将复杂关系的网状结构变成结构简单的以中介者为核心的星形结构，
*每个对象不再和它与之关联的对象直接发生相互作用，而是通过中介者对象来与另一个对象发生相互作用中介者模式中，中介者对象定义了整个系统中厅有实体同事类之间的关系，处于核心地位。
*在整个系统中它主要承担两个方面的责任：
*1、结构上起到中转作用。通过中介者对象对关系的封装，使得吴体的同事类不再需要显示的引用其他对象，通过中介者就可以完成与其他同事类之间的通信。
*2、行为上起到协作作用。中介者对同事类之间的关系进行封装，同事类在不需要与道其他对象的情况一通过中介者与其他对象完成通信。
在这个过程中同事类不需要指明中介者该如何做，中介者可以根据自身的逻辑进行协调，对同事的请求进一步处理，将同事成员之间的关系行为进行分离和封装。
由于有了Mediator对对象的关系进行了封装，使得ConcreteCollenemel和ConcreteColleague2在发送消息和接收消息时通过中介者来完成，减少了同事类之间的耦合度，使得他们可以独立改变和复用。

public class Main4 {
	public static void main(String[] args) {
		ConcreteMediator m=new ConcreteMediator();
		ConcreteColleague1 c1=new ConcreteColleague1(m);
		ConcreteColleague2 c2=new ConcreteColleague2(m);
		m.setColleague1(c1);
		m.setColleague2(c2);
		c1.Send("吃饭了吗");
		c2.Send("没有呢，一起？");
	}
}

//抽象同事类
abstract class Colleague {
	protected Mediator mediator;// 构造方法，得到中介者对象

	public Colleague(Mediator mediator) {
		this.mediator = mediator;
	}
}

//抽象中介者类
abstract class Mediator {
	// 定义一个抽象的发送消息的方法，得到同事对象和发送的消息
	public abstract void Send(String message, Colleague colleague);
}

//具体同事类1
class ConcreteColleague1 extends Colleague {

	public ConcreteColleague1(Mediator mediator) {
		super(mediator);
	}

	public void Send(String message) {
		mediator.Send(message, this);// ConcreteColleague1发送message
	}

	public void Notify(String message) {
		System.out.println("同事1得到消息：" + message);
	}
}
//具体同事类2
class ConcreteColleague2 extends Colleague {

	public ConcreteColleague2(Mediator mediator) {
		super(mediator);
	}

	public void Send(String message) {
		mediator.Send(message, this);// ConcreteColleague1发送message
	}

	public void Notify(String message) {
		System.out.println("同事2得到消息：" + message);
	}
}
//具体中介者类
class ConcreteMediator extends Mediator{

	private ConcreteColleague1 colleague1;
	private ConcreteColleague2 colleague2;
	public ConcreteColleague1 getColleague1() {
		return colleague1;
	}
	public void setColleague1(ConcreteColleague1 colleague1) {
		this.colleague1=colleague1;
	}
	public ConcreteColleague2 getColleague2() {
		return colleague2;
	}
	public void setColleague2(ConcreteColleague2 colleague2) {
		this.colleague2=colleague2;
	}
	public void Send(String message, Colleague colleague) {
		if(colleague==colleague1) {
			colleague2.Notify(message);
		}else {
			colleague1.Notify(message);
		}
		
	}
}

public class Main4 {
	public static void main(String[] args) {
		UnitedNationsSecurity UNSC =new UnitedNationsSecurity();
		USA c1=new USA(UNSC);
		Iraq c2=new Iraq(UNSC);
		UNSC.setColleague1(c1);
		UNSC.setColleague2(c2);
		c1.Declare("No fire!");
		c2.Declare("OK");
	}
}

//联合国机构
abstract class UnitedNations {
	public abstract void Declare(String message, Country colleague);
}

//国家类
abstract class Country {
	protected UnitedNations mediator;

	public Country(UnitedNations mediator) {
		this.mediator = mediator;
	}
}

//美国
class USA extends Country {

	public USA(UnitedNations mediator) {
		super(mediator);
	}

	// 声明
	public void Declare(String message) {
		mediator.Declare(message, this);
	}

	// 获取消息
	public void GetMessage(String message) {
		System.out.println("美国获得对方消息：" + message);
	}
}

//伊拉克
class Iraq extends Country {
	public Iraq(UnitedNations mediator) {
		super(mediator);
	}

	// 声明
	public void Declare(String message) {
		mediator.Declare(message, this);
	}

	// 获取消息
	public void GetMessage(String message) {
		System.out.println("伊拉克获得对方消息：" + message);
	}
}

//联合国安全理事会
class UnitedNationsSecurity extends UnitedNations {
	private USA colleague1;
	private Iraq colleague2;

	// 美国
	public USA getColleague1() {
		return colleague1;
	}

	public void setColleague1(USA colleague1) {
		this.colleague1 = colleague1;
	}

	// 伊拉克
	public Iraq getColleague2() {
		return colleague2;
	}

	public void setColleague2(Iraq colleague2) {
		this.colleague2 = colleague2;

	}

	public void Declare(String message, Country colleague) {
		if (colleague == colleague1) {
			colleague2.GetMessage(message);
		} else {
			colleague1.GetMessage(message);
		}
	}

}

*Mediator模式是一种很有用并且很常用的模式，它将对象间的通信封装到一个类中，将多对多的通信转化为一对多的通信。
Mediator还获得系统解耦的特性，通过Mediator，各个Colleague就不必维护各自通信的对象和通信协议，降低了系统的耦合性，
Mediator和各个Colleague就可以相互独立地修改了。
Mediator模式还有一个很显著的特点就是将控制集中，集中的优点就是便于管理，也正符合了OO设计中的每个类的职责要单一和集中的原则。
如果一组对象之间的通信方式比较复杂，导致相互依赖、结构混乱，可以采用中介者模式，把这些对象相互的交互管理起来。如是一个对象引用很多的对象，并直接跟这些对象交互，导致难以复用该对象，可以采用中介者模式，把这个对象跟其他对象的交互封装到中介者对象旦面。

单一职责模式-桥接模式——手机软件代码实现

合成聚合复用原则：即优先使用对象合成/聚合，而不是类继承，有助于保持每个类并封装，并集中在单个任务上。
这样类和类继承层次会保持较少规模，并且不太可能增长为不可控制的庞然大物。
耦合：两个实体的行为的某种强关联。将它们的强关联去掉，就是耦合的解脱，或称脱耦。
在这里，脱耦是指将抽象化和实现化之间的耦合解脱开，或者说是将它们之间的强关联改换成弱关联。
将两个角色之间的继承关系改为聚合关系，就是蒋它们之间的强关联改换成为弱关联。
因此，桥接模式中的所谓脱耦，就是指：
在一个软件系统的抽象化和实现化之间使用组合/聚合关系而不是继承关系，从而使两者可以相对独立地变化。这就是桥接模式的用意。

public class Main4 {
	public static void main(String[] args) {
		HandsetBrand ab=new HandsetBrandN();
		ab.SetHandsetSoft(new HandsetGame());
		ab.Run();
		ab.SetHandsetSoft(new AddressList());
		ab.Run();
		ab=new HandsetBrandM();
		ab.SetHandsetSoft(new HandsetGame());
		ab.Run();
		ab.SetHandsetSoft(new AddressList());
		ab.Run();
		ab.SetHandsetSoft(new Mp3());
		ab.Run();
			
			
	}
}

//手机软件
abstract class HandsetSoft {
	public abstract void Run();
}

//手机品牌
abstract class HandsetBrand {
	protected HandsetSoft soft;

	// 设置手机软件
	public void SetHandsetSoft(HandsetSoft soft) {
		this.soft = soft;
	}

	// 运行
	public abstract void Run();
}

//手机品牌M
class HandsetBrandM extends HandsetBrand {

	public void Run() {
		System.out.println("M Brand");
		soft.Run();
	}

}
//手机品牌N
class HandsetBrandN extends HandsetBrand {

	public void Run() {
		System.out.println("N Brand");
		soft.Run();
	}

}
//手机游戏
class HandsetGame extends HandsetSoft{

	public void Run() {
		System.out.println("运行手机游戏");
		
	}
	
}
//手机通讯录
class AddressList extends HandsetSoft{

	public void Run() {
		System.out.println("运行手机游戏通讯录");		
	}
	
}
//手机MP3
class Mp3 extends HandsetSoft{

	public void Run() {
		System.out.println("运行手机MP3");
		
	}
	
}

桥接模式代码

public class Main4 {
	public static void main(String[] args) {
		Abstraction ab=new RefinedAbstraction();
		ab.SetImplementor(new ConcreteImplementorA());
		ab.Operation();
		ab.SetImplementor(new ConcreteImplementorB());
		ab.Operation();
	}
}
//Implementor类
abstract class Implementor{
	public abstract void Operation();
}
//具体实现类A
class ConcreteImplementorA extends Implementor{

	public void Operation() {
		System.out.println("具体实现类A的方法执行");
	}
	
}
class ConcreteImplementorB extends Implementor{

	public void Operation() {
		System.out.println("具体实现类B的方法执行");
	}
	
}
//Abstraction类
class Abstraction{
	protected Implementor implementor;
	public void SetImplementor(Implementor implementor) {
		this.implementor=implementor;
	}
	public void Operation() {
		implementor.Operation();
	}
}
//RefinedAbstraction类
class RefinedAbstraction extends Abstraction{
	public void Operation() {
		implementor.Operation();
	}
}

桥接模式就是将抽象部分与它的实现部分分离，其实就是实现系统可能有多角度分类，每一种分类都可能变化，那么就把这种多角度分离出来让它们独立变化，减少它们之间的耦合。
在桥接模式中的桥接是单向的，也就是只能是抽象部分的对象去使用具体实现部分的对象，而不能反过来，也就是个单向桥。
使用Bridge模式和原始解决方案的根本区别在于：
是通过继承还是通过合成/聚合的方式去实现一个功能需求。
因此面向对象分析和设计中有一个原则就是：Favor CompositionOver Inheritance