桥梁模式(Bridge Pattern)

  抽象类的构成.
  1,模板方法,封装了操作的步骤.
  2,具体方法,封装了公共操作.
  3,抽象方法,定义子类一定要实现的操作.
  4,空方法,定义子类的可选实现(抽象方法的便利方法).
继承自一个抽象类的具体子类,它的责任:实现,重写,扩展.
  实现:这是子类的首要责任,它要实现所有的抽象方法.空方法的实现,给了子类可选的余地，只针对自己感兴趣的实现.
  重写:子类可以重写父类的具体方法,改变父类的行为.这是一个风险操作.模板方法更是不推荐重写的方法.
  扩展:理想继承是没有扩展这一项的,但类的发展总意为着更强,增加功能就是这一体现.

一个类的继承承载的责任太多,有可能出现责任混乱.Bridge Pattern将功能扩展和实现分为两套继承体系.便得这两方面可以独立演变.两套继承体系的顶层抽象可能没有共同接口,但它们仍是对同一概念的两方面描述.功能增强所保留的实现的一个引用,就是Bridge.这样做的好处就是:单独的继承实现被绑定,在编译期已确定.而现再把实现封装成类,把原本的继承关系改为组合关系,实现可以被动态的改变.

例子:
  功能扩展体系:
 

  //定义功能的顶层类
  public class Display {
    //实现交给DisplayImpl, impl充当Bridge
    protected DisplayImpl impl;
    public Display(DisplayImpl impl) {
        this.impl = impl;
    }
    public void open() {
        impl.rawOpen();
    }
    public void print() {
        impl.rawPrint();
    }
    public void close() {
        impl.rawClose();
    }
    public final void display() {
        open();
        print();
        close();
    }
  }
  

  实现的体系:
 

  //实现的顶层类
  public abstract class DisplayImpl {
    public abstract void rawOpen();
    public abstract void rawPrint();
    public abstract void rawClose();
 }
 
  

 

     //扩展功能
    public class CountDisplay extends Display {
       public CountDisplay(DisplayImpl impl) {
           super(impl);
       }
       //增加一个方法
       public final void multiDisplay(int num) {
           open();
           for (int i = 0; i < num; i++) {
               print();
           }
           close();
       }
   }
  

 //一个实现
  public class StringDisplayImpl {
    private String string;
	private int width;
	public StringDisplayImpl(String str) {
	   this.string = str;
	   this.width  = str.length();
	}
	public void rawOpen() {
	   printLine();
	}
	public void rawPrint() {
	   System.out.println("|" + string + "|");
	}
	public void rawClose() {
	   printLine();
	}
	private void printLine() {
		System.out.print("+");
	  for (int i = 0; i < width; i++)
	  {
               System.out.print("-");
	  }
	  System.out.println("+");
	}
   }

   public class Main
   {
	public static void main(String[] args) {
            //自由组合功能和实现.
	   Display display = new Display(new StringDisplayImpl("kitty"));
	   display.display();
	   CountDisplay count = new CountDisplay(new StringDisplayImpl("owen"));
	   count.multiDisplay(10);
	   RandomDisplay random = new RandomDisplay(new StringDisplayImpl("aa"));
	   random.randomDisplay();
	}
}

写在后面:
  参考书上说这个模式是不太常用的模式,但这个模式对面向对象的思考,理解面向对象的设计原则很有帮助.将单纯的继承强耦合解耦成组合的弱耦合.