九、Bridge模式:将类的功能层次结构与实现层次结构分离
类的两个层次结构和作用
类的功能层次结构:希望增加新功能时
父类有基本功能,在子类中增加新功能
Something父类
…├─SomethingGood子类
想要再增加新功能
Something父类
…├─SomethingGood子类
… …├─SomethingBetter子类
注:通常,类的层次结构关系不应过深
类的实现层次结构:希望增加新的实现时
回顾 Template Method模式,定义了抽象类,有多个子类实现。
父类通过 声明抽象方法 来 定义 接口(API)
子类通过 实现具体方法 来 实现 接口(API)
AbstractClass抽象类
…├─ConcreteClass具体实现类
… …├─AnotherConcreteClass具体实现类
当类的层次结构只有一层时,功能层次结构与实现层次结构是混杂在一个层次结构中的。
这样很容易使类的层次结构变得复杂,难理解。因为自己难确定应该在类的哪一个层次结构中去增加子类。
因此,我们需要将“类的功能层次结构”与“类的实现层次结构”分离为两个独立的类层次结构。
如果只是简单地将它们分开,两者之间必然会缺少联系。所以我们需要Bridge模式在它们之间搭建一座桥梁。
示例程序类图
Display
public class Display {private DisplayImpl impl;public Display(DisplayImpl impl) {this.impl = impl;}// 注意这3个方法的实现,都调用了impl字段的实现方法。// 这样,Display的接口(API)就被转换成为了 DisplayImpl的接口(API)。public void open() {impl.rawOpen();}public void print() {impl.rawPrint();}public void close() {impl.rawClose();}// display方法调用 open、print、Close这3个Display类的接口(API)进行了“显示”处理。public final void display() {open();print();close();}
}
CountDisplay
public class CountDisplay extends Display {public CountDisplay(DisplayImpl impl) {super(impl);}// 循环显示times次public void multiDisplay(int times) {open();for (int i = 0; i < times; i++) {print();}close();}
}
StringDisplayImpl
public class StringDisplayImpl extends DisplayImpl {private String string; // 要显示的字符串private int width; // 以字节单位计算出的字符串的宽度public StringDisplayImpl(String string) { // 构造函数接收要显示的字符串stringthis.string = string; // 将它保存在字段中this.width = string.getBytes().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++) { // 显示width个"-"System.out.print("-"); // 将其用作方框的边框}System.out.println("+"); // 显示用来表示方框的角的"+"}
}
Main
public class Main {public static void main(String[] args) {// 虽然变量d1中保存的是Display类的实例,而变量d2和d3中保存的是CountDisplay类的实例// 但它们内部都保存着StringDisplayImp1类的实例。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.display();d3.multiDisplay(5);}
}
角色
-
Abstraction(抽象化)
位于“类的功能层次结构”的最上层。它使用Implementor角色的方法定义了基本的功能。该角色中保存了Implementor角色的实例。
示例中是Display类。 -
RefinedAbstraction(改善后的抽象化)
在 Abstraction角色的基础上增加了新功能的角色。
示例中是CountDisplay类。 -
Implementor(实现者)
位于“类的实现层次结构”的最上层。它定义了用于实现Abstraction角色的接口(API)的方法。
示例中是DisplayImpl类。 -
Concretelmplementor(具体实现者)
负责实现在Implementor角色中定义的接口(API)。
示例中是StringDisplayImpl类。
扩展思路的要点
分开后更容易扩展
Bridge 模式的特征:将“类的功能层次结构”与“类的实现层次结构”分离开。
将类的这两个层次结构分离开有利于独立地对它们进行扩展。
当想要增加功能时,只需要在“类的功能层次结构”一侧增加类,不必对“类的实现层次结构”做任何修改。
而且,增加后的功能可被“所有的实现”使用。
继承是强关联,委托是弱关联
继承是强关联关系,委托是弱关联关系。
虽然使用“继承”很容易扩展类,但是类之间也形成了一种强关联关系,可使用“委托”来代替“继承”关系。
示例程序的Display类中使用了“委托”,Display类的impl字段保存了实现的实例,类的任务就发生了转移。
调用open 方法会调用impl.rawOpen()方法
调用print方法会调用impl.rawPrint()方法
调用close方法会调用impl.rawClose()方法
也就是说,当其他类要求 Display类“工作”的时候,Display类并非自己工作,而是将工作“交给impl”。这就是“委托”。
在Template Method模式(第3章)中也讨论了继承和委托的关系,可以再回顾下。
相关的设计模式
-
Template Method模式(第3章)
在 Template Method 模式中使用了“类的实现层次结构”。父类调用抽象方法,而子类实现抽象方法。
-
Abstract Factory 模式(第8章)
为了能根据需求设计出良好的Concretelmplementor角色,有时我们会使用Abstract Factory 模式。
-
Adapter模式(第2章)
使用 Bridge模式可以将类的功能层次结构与类的实现层次结构分离,并在此基础上使这些层次结构结合起来。
而使用 Adapter 模式则可以结合那些功能上相似但是接口(API)不同的类。
十、Strategy模式:整体地替换算法
Strategy 的意思是“策略”,指的是与敌军对垒时行军作战的方法。在编程中,可以将它理解为“算法”。
使用Strategy模式可以整体地替换算法的实现部分。
能够整体地替换算法,可以方便地以不同的算法去解决同一个问题。
示例程序的功能是让电脑玩“猜拳”游戏。
考虑了两种猜拳的策略。
第一种策略是“如果这局猜拳获胜,那么下一局也出一样的手势”(WinningStrategy),这是一种稍微有些笨的策略;
第二种策略是“根据上一局的手势从概率上计算出下一局的手势”(ProbStrategy)。
示例程序类图
Hand
Hand表示猜拳游戏中的“手势”的类
虽然Hand类会被其他类(Player类、WinningStrategy类、Probstrategy类)使用,
但它并非 Strategy 模式中的角色。
public class Hand {public static final int HANDVALUE_GUU = 0; // 表示石头的值public static final int HANDVALUE_CHO = 1; // 表示剪刀的值public static final int HANDVALUE_PAA = 2; // 表示布的值public static final Hand[] hand = { // 表示猜拳中3种手势的实例new Hand(HANDVALUE_GUU),new Hand(HANDVALUE_CHO),new Hand(HANDVALUE_PAA),};private static final String[] name = { // 表示猜拳中手势所对应的字符串"石头", "剪刀", "布",};private int handvalue; // 表示猜拳中出的手势的值private Hand(int handvalue) {this.handvalue = handvalue;}public static Hand getHand(int handvalue) { // 根据手势的值获取其对应的实例return hand[handvalue];}public boolean isStrongerThan(Hand h) { // 如果this胜了h则返回truereturn fight(h) == 1;}public boolean isWeakerThan(Hand h) { // 如果this输给了h则返回truereturn fight(h) == -1;}private int fight(Hand h) { // 计分:平0, 胜1, 负-1if (this == h) {return 0;} else if ((this.handvalue + 1) % 3 == h.handvalue) {return 1;} else {return -1;}}public String toString() { // 转换为手势值所对应的字符串return name[handvalue];}
}
Strategy
public interface Strategy {// 获取下一局要出的手势。调用该方法后,实现了strategy接口的类会绞尽脑汁想出下一局出什么手势。public abstract Hand nextHand();// 学习“上一局的手势是否获胜了”,Strategy接口的实现类就会根据参数改变自己的内部状态public abstract void study(boolean win);
}
WinningStrategy
import java.util.Random;public class WinningStrategy implements Strategy {private Random random;private boolean won = false;// 上一局出的手势private Hand prevHand;public WinningStrategy(int seed) {random = new Random(seed);}public Hand nextHand() {if (!won) {prevHand = Hand.getHand(random.nextInt(3));}return prevHand;}public void study(boolean win) {won = win;}
}
ProbStrategy
import java.util.Random;public class ProbStrategy implements Strategy {private Random random;private int prevHandValue = 0;private int currentHandValue = 0;// history[上一局出的手势][这一局所出的手势],值越大表示过去的胜率越高private int[][] history = {{ 1, 1, 1, },{ 1, 1, 1, },{ 1, 1, 1, },};public ProbStrategy(int seed) {random = new Random(seed);}public Hand nextHand() {int bet = random.nextInt(getSum(currentHandValue));int handvalue = 0;if (bet < history[currentHandValue][0]) {handvalue = 0;} else if (bet < history[currentHandValue][0] + history[currentHandValue][1]) {handvalue = 1;} else {handvalue = 2;}prevHandValue = currentHandValue;currentHandValue = handvalue;return Hand.getHand(handvalue);}private int getSum(int hv) {int sum = 0;for (int i = 0; i < 3; i++) {sum += history[hv][i];}return sum;}// study方法会根据nextHand方法返回的手势的胜负结果来更新history字段中的值。public void study(boolean win) {if (win) {history[prevHandValue][currentHandValue]++;} else {history[prevHandValue][(currentHandValue + 1) % 3]++;history[prevHandValue][(currentHandValue + 2) % 3]++;}}
}
Player
public class Player {private String name;private Strategy strategy;// wincount、losecount 和 gamecount 用于记录选手的猜拳结果。private int wincount;private int losecount;private int gamecount;public Player(String name, Strategy strategy) { // 赋予姓名和策略this.name = name;this.strategy = strategy;}// 获取下一局手势的方法,不过实际上决定下一局手势的是各个策略。// nextHand方法将自己的工作委托给了 Strategy,这就形成了一种委托关系。public Hand nextHand() { // 策略决定下一局要出的手势return strategy.nextHand();}// Player类会通过strategy字段调用 study方法,然后study 方法会改变策略的内部状态。public void win() { // 胜strategy.study(true);wincount++;gamecount++;}public void lose() { // 负strategy.study(false);losecount++;gamecount++;}public void even() { // 平gamecount++;}public String toString() {return "[" + name + ":" + gamecount + " games, " + wincount + " win, " + losecount + " lose" + "]";}
}
Main
public class Main {public static void main(String[] args) {if (args.length != 2) {System.out.println("Usage: java Main randomseed1 randomseed2");System.out.println("Example: java Main 314 15");System.exit(0);}int seed1 = Integer.parseInt(args[0]);int seed2 = Integer.parseInt(args[1]);// 在生成Player类的实例时,需要向其传递“姓名”和“策略”。Player player1 = new Player("Taro", new WinningStrategy(seed1));Player player2 = new Player("Hana", new ProbStrategy(seed2));for (int i = 0; i < 10000; i++) {Hand nextHand1 = player1.nextHand();Hand nextHand2 = player2.nextHand();if (nextHand1.isStrongerThan(nextHand2)) {System.out.println("Winner:" + player1);player1.win();player2.lose();} else if (nextHand2.isStrongerThan(nextHand1)) {System.out.println("Winner:" + player2);player1.lose();player2.win();} else {System.out.println("Even...");player1.even();player2.even();}}System.out.println("Total result:");System.out.println(player1.toString());System.out.println(player2.toString());}
}
角色
-
Strategy (策略)
负责决定实现策略所必需的接口(API)。
示例中是:Strategy接口。
-
ConcreteStrategy (具体的策略)
负责实现 Strategy角色的接口(API),即负责实现具体的策略(战略、方向、方法和算法)。
示例中是:WinningStrategy类、ProbStrategy类。
-
Context(上下文)
负责使用 Strategy角色。Context角色保存了ConcreteStrategy角色的实例,并使用ConcreteStrategy角色去实现需求(总之,还是要调用 Strategy角色的接口(API))。
示例中是:Player类。
拓展思路的要点
为什么需要特意编写 Strategy角色
当想通过改善算法来提高算法的处理速度时,如果使用了 Strategy模式,仅修改ConcreteStrategy角色即可,就不必修改Strategy角色的接口(API)了。
而且,使用委托这种弱关联关系可以很方便地整体替换算法。
例如,如果想比较原来的算法与改进后的算法的处理速度有多大区别,简单地替换下算法即可进行测试。
使用 Strategy模式编写象棋程序时,可以方便地根据棋手的选择切换AI例程的水平。
程序运行中也可以切换策略
如果使用 Strategy模式,在程序运行中也可以切换 ConcreteStrategy角色。
例如,在内存容量少的运行环境中可以使用 SlowBut LessMemoryStrategy(速度慢但省内存的策略),而在内存容量多的运行环境中则可以使用 FastButMoreMemoryStrategy(速度快但耗内存的策略)。
此外,还可以用某种算法去“验算”另外一种算法。
例如,假设要在某个表格计算软件的开发版本中进行复杂的计算。这时,我们可以准备两种算法,即“高速但计算上可能有 Bug的算法”和“低速但计算准确的算法”,然后让后者去验算前者的计算结果。
相关的设计模式
-
Flyweight 模式(第20章)
有时会使用 Flyweight模式让多个地方可以共用 ConcreteStrategy 角色。
-
Abstract Factory 模式(第8章)
使用 Strategy模式可以整体地替换算法。
使用 Abstract Factory 模式则可以整体地替换具体工厂、零件和产品。 -
State 模式(第19章)
使用 Strategy模式和 State模式都可以替换被委托对象,而且它们的类之间的关系也很相似,但是两种模式的目的不同。
在 Strategy模式中,ConcreteStrategy角色是表示算法的类,并且可以替换被委托对象的类(非必要也可不替换)。
而在 State 模式中,ConcreteState角色是表示“状态”的类,并且每次状态变化时,被委托对象的类都必定会被替换。