设计模式 (二十三) 桥梁模式

桥梁模式

桥梁模式的背景：一个公司生产产品，如果是一个确定的公司，且生产固定的产品。那么这个类实现起来可能就比较确定，比如这样：

public abstract class corp{
	protected abstract void produce();
	protected abstract void sell();
	public void makeMoney(){
		this.produce();
		this.sell();
	}
}


public class HouseCorp extends Corp{

	@Override
	protected void produce(){
		System.out.println("房地产公司盖房");
	}
	@Override
	protected void sell(){
		System.out.println("卖房");
	}
  @Override
  public void makeMoney(){
		super.makeMoney();
		System.out.println("房地产公司赚钱");
	}
}

现在有个卖服装的，那么他生产服装，卖服装。这样一个工厂卖的公司是死的，是固定的。如果再换产品，需要再建个工厂类，从现实意义上讲，重建工厂类，就是把以前的厂房都废弃了，再建立个新厂子，这在实际中是不科学的。

所以，需要进行改进，如何改进？

工厂和产品进行解藕。

public abstract class Product{
	public abstract void beProducted();
	public abstract void beSelled();
}

public class House extends Product{

@Ｏverride
	public void beProducted(){
		System.out.println("生产出的房子");
	}
	@Override
	 public void beSelled(){
		System.out.println("生产出的房子卖出去了")；
	}
}

public class Ipod extends Product{
@Override
	public void beProducted(){
		System.out.println("生产卖ipod");
	}
@Override
public void beSelled(){
	System.out.println("卖了ipod");
}
}

这样是一个product产品类

再来看公司类，以前公司是生产产品固定的。
现在要解藕了

public abstract class Corp{
	private Product product;
	public Corp(Product product){
		this.product=product;
	}
	public void makeMoney(){
		this.product.beProducted();
		this.product.beSelled();
	}
}

public class HouseCorp extends Corp{
	
	public HouseCorp(House house){
		super(house);
	}

	@Override
	public void makeMoney(){
		super.makeMoney();
		System.out.println("房地产公司挣钱");
	}
}

这样工厂和产品就解藕了。一个工厂可以生产多个产品了。
只要新建并传进去不同的产品类就可以了。

桥梁模式的类图

在这里插入图片描述

桥梁模式的角色：

Abstraction。抽象化角色。主要职责是定义该角色的行为，同时保存一个实现化角色的引用。该角色一般是抽象类。
Implementor。实现化角色。是接口或是抽象类。定义角色需要的行为和属性。
RefinedAbstraction。修正抽象化角色。引用实现化角色对抽象化角色进行修正。
ConcreteImplementor。具体实现化角色。实现接口或抽象类定义的方法和属性。

public interface Implementor{
	public void doSomething();
	public void doAnything();
}

public class ConcreteImplementor1 implements Implementor{
	
	public void doSomething(){}
	public void doAnything(){}
}

public class ConcreteImplementor2 implements Implementor{
	
	public void doSomething(){}
	public void doAnything(){}
}


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;
	}
}

public  class RefinedAbstraction extends Abstraction{
	
	private Implementor imp;
	public RefinedAbstraction(Implementor imp){
		super(imp);
	}
	public void request(){
		super.request();
		super.getImp().doAnything();
	}

}


public class Client{
	public static void main(String[] args){
		Implementor imp=new ConcreteImplementor1();
		Abstraction abs=new RefinedAbstraction(imp);
		abs.request();
	}
}

桥梁模式的优点

抽象和实现分离。桥梁模式的主要特点就是抽象和实现分离。它完全是解决继承的缺点而提出的设计模式，在此模式下，实现可以不受抽象的约束，不用再绑定在一个固定的抽象层次上。
优秀的扩充能力。
实现细节对客户透明。

桥梁模式的使用场景

不希望或不适合使用继承的场景
接口或抽象类不稳定的场景
重用性要求较高的场景

桥梁模式的注意事项

桥梁模式比较简单，主要应该考虑的是如何拆分抽象和实现。当在一个系统设计时，发现类的继承有Ｎ层时，可以考虑使用桥梁模式