设计模式学习笔记——桥梁模式

定义：

将抽象和实现解耦，使得两者可以独立地变化。（抽象角色引用实现角色，实现抽象角色的部分实现）

 

桥接模式主要是为了补充继承的缺点的，继承有什么缺点呢？即强侵入，父类有这个方法，子类也必须有这个方法，这是不可选择的，会带来扩展性的问题。比如A类有一个方法，B类继承了A类的这个方法，C类继承了B类的这个方法，如果B类要重写父类的这个方法，那么它就要修改和C类的关系，这就带来了很大的风险。

通用类图如下：

代码：

//抽象化角色
public abstract class Abstraction {
	private Implementor implementor;

	//这里在抽象类中增加了一个构造函数，是为了提醒子类，尽量明确的指定实现者
	public Abstraction(Implementor implementor) {
		this.implementor = implementor;
	}

	public Implementor getImplementor() {
		return implementor;
	}

	public void setImplementor(Implementor implementor) {
		this.implementor = implementor;
	}

	//自身的属性和行为
	public void request(){
		this.implementor.doSomething();
	}
}

//抽象化角色的具体实现
public class ConcreteAbstraction1 extends Abstraction{

	public ConcreteAbstraction1(Implementor implementor) {
		super(implementor);
	}

	//重写父类的行为
	@Override
	public void request() {
		super.request();
		super.getImplementor().doAnything();
	}
}

//抽象化角色的具体实现
public class ConcreteAbstraction2 extends Abstraction{

	public ConcreteAbstraction2(Implementor implementor) {
		super(implementor);
	}

	//重写父类的行为
	@Override
	public void request() {
		// TODO Auto-generated method stub
		super.request();
		super.getImplementor().doAnything();
	}
}

//实现类的接口
public interface Implementor {
	public void doSomething();
	public void doAnything();
}

public class ConcreteImpl1 implements Implementor {

	@Override
	public void doSomething() {
		System.out.println("1 do some thing...");
	}

	@Override
	public void doAnything() {
		System.out.println("1 do any thing...");
	}

}

public class ConcreteImpl2 implements Implementor {

	@Override
	public void doSomething() {
		System.out.println("2 do some thing...");
	}

	@Override
	public void doAnything() {
		System.out.println("2 do any thing...");
	}

}

public class Client {
	public static void main(String[] args) {
		Implementor implementor2=new ConcreteImpl2();
		Abstraction abs=new ConcreteAbstraction2(implementor2);
		
		abs.request();
		
		
		Implementor implementor1=new ConcreteImpl1();
		Abstraction abs1=new ConcreteAbstraction2(implementor1);
		
		abs1.request();
	}
}

桥梁模式的优点：

1、  抽象和实现分离

实现可以完全不受抽象的约束，不用再绑定在一个固定的抽象层次上，解决了继承的缺点。

2、优秀的扩展能力

         抽象和实现都可以独立的进行扩展。

3、  实现细节对客户的透明

客户不用关心细节的实现，它已经通过抽象层通过聚合关系完成了封装。

 

桥梁模式的使用场景：

1、  不希望或不使用使用继承的场景，例如继承层次过度，无法更细化设计颗粒；

2、抽象或接口不稳定的场景；

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