九、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) { // 构造函数接收要显示的字符串string
this.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则返回true
return fight(h) == 1;
}
public boolean isWeakerThan(Hand h) { // 如果this输给了h则返回true
return fight(h) == -1;
}
private int fight(Hand h) { // 计分：平0, 胜1, 负-1
if (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角色是表示“状态”的类，并且每次状态变化时，被委托对象的类都必定会被替换。
