》》Bridge 模式是将两样东西连接起来,它们分别是类的功能层次结构和
类的实现层次结构。
》》类的层次结构的两个作用:
------希望增加新功能时
**** 父类具有基本功能
****子类增加新的功能
------希望增加新的实现时
****父类通过声明抽象方法来定义接口(API)
****子类通过实现具体方法来实现接口(API)
------类的层次结构的混杂与分离
-------------------下面示例程序的功能是“显示一些东西”
》》示例程序的类图:
说明:左侧的两个类构成了"类的功能层次结构",右侧的两个类构成了“类的实现层次结构”。
类的两个层次结构之间的桥梁是 (DisplayImpl )impl 属性。
》》类的功能层次结构:Display 类
package bridge.function;
import bridge.realize.DisplayImpl;
public class Display {
private 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();
}
}
》》类的功能层次结构:CountDisplay 类
package bridge.function;
import bridge.realize.DisplayImpl;
public class CountDisplay extends Display {
public CountDisplay(DisplayImpl impl){
super(impl);
}
public void multiDisplay(int times){ //循环显示 times 次
open();
for(int i = 0 ; i < times ; i++){
print();
}
close();
}
}
》》类的实现层次结构:DisplayImpl 类
package bridge.realize;
public abstract class DisplayImpl {
public abstract void rawOpen();
public abstract void rawPrint();
public abstract void rawClose();
}
》》类的实现层次结构:StringDisplayImpl 类
package bridge.realize;
public class StringDisplayImpl extends DisplayImpl {
private String string; //要显示的字符串
private int width; //以字节单位计算出的字符串的宽度
public StringDisplayImpl(String string){ //构造函数接收要显示的字符串string
this.string = string; //将它保存在属性中
this.width =string.getBytes().length; //把字符串的宽度也保存在属性中,以供使用
}
public void rawOpen() {
printLine();
}
public void rawPrint() {
System.out.println("|"+string+"|"); //前后加上“|”并显示
}
public void rawClose() {
printLine();
}
public void printLine(){
System.out.print("+"); //显示用来表示方框的角的“+”
for(int i = 0 ; i< width ; i++){ //显示 width 个 "-"
System.out.print("-"); //将其用作方框的边框
}
System.out.println("+"); //显示用来表示方框的角的“+”
}
}
》》测试程序:Main2 类
package ceshi;
import bridge.function.CountDisplay;
import bridge.function.Display;
import bridge.realize.StringDisplayImpl;
public class Main2 {
public static void main(String[] args){
Display d1 = new Display(new StringDisplayImpl("Hello, China."));
Display d2 = new CountDisplay(new StringDisplayImpl("Hello , World."));
CountDisplay d3 = new CountDisplay(new StringDisplayImpl("Hello , Universe."));
d1.display();
d2.display();
d3.multiDisplay(5);
}
}
-------------------
《运行结果》
-----------------------------------------------
《Bridge 模式中的登场角色》
***** Abstraction (抽象化)
该角色位于“类的功能层次结构”的最上层。它使用 Implementor 角色
的方法定义了基本的功能。该角色中保存了 Implementor 角色的实例。
在示例程序中,由 Display 类扮演此角色。
**** RefinedAbstraction (改善后的抽象化)
在 Abstraction 角色的基础上增加了新功能的角色。在示例程序中,
由 CountDisplay 类扮演此角色。
**** Implementor (实现者)
该角色位于“类的实现层次结构”的最上层。它定义了用于实现Abstraction
角色的接口(API)的方法。在示例程序中,由 DisplayImpl 类扮演此角色。
**** ConcreteImplementor(具体的实现者)
该角色负责实现在 Implementor 角色中定义的接口(API) 。在示例
程序中,由 StringDisplayImpl 类扮演此角色。
---------------------------------------------------------
《扩展思路的要点》
1.分开后更容易扩展
Bridge 模式的特征是将“类的功能层次结构”与“类的实现层次结构”分离
开了。将类的这两个层次结构分离开有利于独立地对它们进行扩展。
当想要增加功能时,只需要在“类的功能层次结构”一侧增加类即可,不必
对“类的实现层次结构”做任何修改。而且,增加后的功能可以被“所有的实现”
使用。
2.继承是强关联,委托是弱关联
虽然使用“继承”很容易扩展类,但是类之间也形成了一种强关联关系。
如果想要很轻松地改变类之间的关系,使用继承就不适合了,因为每次
改变类之间关系时都需要修改程序。这时,我们使用“委托”来代替“继承”
关系。
继承是强关联关系,委托是弱关联关系。
--------------------------------------------------------------
《相关的设计模式》
**** Template Method 模式
**** Abstract Factory 模式
**** Adapter 模式