* 24种设计模式——桥梁模式

定义：将抽象和实现解耦，使得两者可以独立地变化。

抽象角色引用实现角色，或者说抽象角色的部分实现是由实现角色完成的。

当发现类的继承有N层时，可以考虑使用桥梁模式。

一、公司产品生产、销售和赚钱

1. 抽象产品类

public abstract class Product {
	//甭管是什么产品它总要能被生产出来
	public abstract void beProducted();
	//生产出来的产品，一定要销售出去，否则亏本
	public abstract void beSelled();
}

2. 房子

public class House extends Product{
	//生产房子
	public void beProducted() {
		System.out.println("生产出的房子是这样的...");
	}
	//销售房子
	public void beSelled() {
		System.out.println("生产出的房子卖出去了...");
	}
}

3. IPod

public class IPod extends Product{
	public void beProducted() {
		System.out.println("生产出的iPod是这样的...");
	}
	public void beSelled() {
		System.out.println("生产出的iPod卖出去了...");
	}
}

4. 服装

public class ClothesCorp extends Product{
	public void beProducted() {
		System.out.println("服装公司生产衣服...");
	}
	public void beSelled() {
		System.out.println("服装公司出售衣服...");
	}
}

5. 抽象公司类

public abstract class Corp {
	//定义一个抽象的产品对象，不知道具体是什么产品
	private Product product;
	//构造函数，由子类定义传递具体的产品进来
	public Corp(Product product) {
		this.product = product;
	}
	//公司是干什么的？赚钱的
	public void makeMoney() {
		//先生产
		this.product.beProducted();
		//然后销售
		this.product.beSelled();
	}
}

6. 房地产公司

public class HouseCorp extends Corp{
	//定义传递一个House产品进来
	public HouseCorp(House house) {
		super(house);
	}
	//房地产公司赚钱，计算利润
	public void makeMoney() {
		super.makeMoney();
		System.out.println("房地产公司赚钱了...");
	}
}

7. 山寨公司

public class ShanZhaiCorp extends Corp{
	//产什么产品，不知道，等被调用的才知道
	public ShanZhaiCorp(Product product) {
		super(product);
	}
	//狂赚钱
	public void makeMoney() {
		super.makeMoney();
		System.out.println("赚钱了...");
	}
}

8. 场景类

public class Client {
	public static void main(String[] args) {
		House house = new House();
		System.out.println("----房地产公司是这样运行的----");
		//先找到我的公司
		HouseCorp houseCorp = new HouseCorp(house);
		//看我怎么的挣钱
		houseCorp.makeMoney();
		//山寨公司生产的产品很多，不过我只要指定产品就成了
		System.out.println("----山寨公司是这样运行的----");
		ShanZhaiCorp shanZhaiCorp = new ShanZhaiCorp(new IPod());
		shanZhaiCorp.makeMoney();
		System.out.println("----服装公司是这样运行的----");
		ShanZhaiCorp shanZhaiCorp1 = new ShanZhaiCorp(new ClothesCorp());
		shanZhaiCorp1.makeMoney();
	}
}

这样以后，不管是增加公司，还是增加产品， 都是在扩展的基础上进行，比如，

1）增加公司，要么继承Corp类，要么继承HouseCorp或ShanZhaiCorp，不用再修改原有的类了。

2）增加产品，继承Product类，或者继承House类，你要把房子分为公寓、商业用户等。

二、桥梁模式的定义

定义：将抽象和实现解耦，使得两者可以独立地变化。

抽象角色引用实现角色，或者说抽象角色的部分实现是由实现角色完成的。

1. 实现化角色

public interface Implementor {
	//基本方法
	public void doSomething();
	public void doAnything();
}

2. 具体实现化角色

public class ConcreteImplementor1 implements Implementor{
	public void doSomething() {
		//业务逻辑处理
	}
	public void doAnything() {
		//业务逻辑处理
	}
}

&

public class ConcreteImplementor2 implements Implementor{
	public void doSomething() {
		//业务逻辑处理
	}
	public void doAnything() {
		//业务逻辑处理
	}
}

3. 抽象化角色

public abstract class Abstraction {
	//定义对实现化角色的引用
	private Implementor imp;
	//约束子类必须实现该构造函数
	public Abstraction(Implementor imp) {
		this.imp = imp;
	}
	//自身的行为和属性
	public void request(){
		this.imp.doSomething();
	}
	//获得实现化角色
	public Implementor getImp(){
		return imp;
	}
}

4. 具体抽象化角色

public class RefinedAbstraction extends Abstraction{
	//重写构造函数
	public RefinedAbstraction(Implementor imp) {
		super(imp);
	}
	//修正父类的行为
	public void request() {
		/*
		 * 业务处理
		 */
		super.request();
		super.getImp().doAnything();
	}
}

5. 场景类

public class Client {
	public static void main(String[] args) {
		//定义一个实现化角色
		Implementor imp = new ConcreteImplementor1();
		//定义一个抽象化角色
		Abstraction abs = new RefinedAbstraction(imp);
		//执行定义
		abs.request();
	}
}

三、桥梁模式的应用

1. 优点

1）抽象和实现分离

这是桥梁模式的主要特点，它完全为了解决继承的缺点而提出的设计模式，在该模式下，实现可以不受抽象的约束，不用再绑定在一个固定的抽象层次上。

2）优秀的扩充能力

增加实现、增加抽象都没问题，只要对外暴露的接口层允许这样的变化，我们已经把变化的可能性减至最小。

3）实现细节对客户透明

细节的实现 ，它已经由抽象层通过聚合关系完成了封装

2. 桥梁模式的使用场景 

1）不希望或不适用使用继承的场景

例如继承层次过渡、无法更加细化设计颗粒等场景，需要考虑使用桥梁模式

2）接口或抽象类不稳定的场景

明知道接口不稳定还想通过实现或继承来实现业务需求，那是得不偿失的，也是比较失败的做法。

3）重用性要求较高的场景

设计的颗粒度越细，则被重用的可能性就越大，而采用的继承则受父类的限制，不可能出现太细的颗粒度。