9 Bridge模式——将类的功能层级结构与实现层次结构分离

9.1 Bridge模式

Bridge模式的作用是将两样东西连接起来，它们分别是类的功能层次和类的实现层次。

类测层次结构的两个作用

• 希望增加新功能是

假设现在有一个类Something。当我们想在Something中增加新功能时，会编写一个Something的子类(派生类)，即SomethingGood类。这样就构成了一个小小的类层级结构。

这就是为了增加新功能而产生的层级结构。

• 父类具有基本功能
• 在子类中增加新的功能

以上这种层次结构被称为“类的功能层次结构”。

• 希望增加新的实现时

抽象类声明了一些抽象方法，定义了接口，然后子类负责去实现这些抽象方法。父类的任务是通过声明抽象方法定义接口。然后子类的任务是实现抽象方法。正是由于父类和子类的这种任务分担，我们才可以编写出具有高可替换性的类。
但是，这里的类层次结构并非用于增加功能，也就是说，这种层次结构并非用于方便增加新的方法。它的真正作用是帮助我们实现下面的任务分担。

• 父类通过声明抽象方法来定义接口
• 子类通过实现具体的方法来实现接口

这种层次结构被称为“类的实现层级结构”

• 类的层级结构的混杂与分离

9.2 示例

类的功能层级结构：Display

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类

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类

public abstract class DisplayImpl {
    public abstract void rawOpen();
    public abstract void rawPrint();
    public abstract void rawClose();
}

9.3 Bridge模式中的角色

• Abstraction(抽象化) 该角色位于“类的功能层级结构”的最上层。它使用Implementor角色的方法定义了基本的功能。该角色中保存了Implementor角色的实例。
• RefinedAbstraction(改善后的抽象化)：在Abstraction基础上增加了新功能的角色
• Implementor(实现者)：该角色位于“类的实现层次结构”，定义了用于实现Abstraction角色的接口。
• ConcreteImplementor(具体的实现者)：该角色负责实现Implementor角色中定义的接口。

10 Strategy模式——整体替换地算法

策略模式

10.2 示例程序

类和接口的一览表

Hand类

虽然Hand类会被其他类使用，但是它并非策略模式中的角色。

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 {
    Hand nextHand();
    void study(boolean win);
}

WinningStrategy

public class WinningStrategy implements Strategy {
    private Random random;
    private boolean won = false;
    private Hand prevHand;
    public WinningStrategy(int seed) {
        random = new Random(seed);
    }
    @Override
    public Hand nextHand() {
        if (!won) {
            prevHand = Hand.getHand(random.nextInt(3));
        }
        return prevHand;
    }
    @Override
    public void study(boolean win) {
        won = win;
    }
}

10.3 Strategy模式中的角色

策略模式有以下几种角色

• Strategy(策略) 负责实现策略所必需的接口。
• ConcreteStrategy(具体的策略)：负责实现具体的策略。
• Context(上下文)：保存了ConcreteStrategy角色的实例。