《图解设计模式》笔记（四）分开考虑

九、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角色是表示“状态”的类，并且每次状态变化时，被委托对象的类都必定会被替换。