Bridge 模式--将类的功能层次结构和实现层次结构分离
1. 在书中提出了一个值得思考问题：
类的层次结构有什么作用？
- 当我们想要增加新的功能（体现类的功能层次结构）
1.1 父类具有基本功能
1.2 子类需要扩展或者增强（如果我们想要保持灵活性就需要功能扩展的粒度上做文章）- 当我们想要增加新的实现（体现类的实现层次结构）
2.1 父类通过声明抽象方法来定义接口API
2.2 子类通过实现具体方法来实现接口API（同一个父类可以有不同的实现途径）- 所以我们设计子类的时候就可以思考，我们是为了增强功能还是增强实现？
很显然的是，如果我们只有一层子类，我们就直接把 增强和实现 堆叠在一起，当我们再要继承子类时，或者当我们需要再继承子类的子类时，我们的层级结构就会越来越耦合，越来越堆叠。但是吗他们的核心就是为父类提供服务的，提供实现或者提供增强，一刀切也是有问题的。中间的连接便是这个模式的主人公 Bridge。
2. 需求
image.png
3. UML
image.png
4. Code
4.1 Display
/**
* 类功能层次结构：是类的功能层次的最上层
* @author CSZ
*/
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();
}
}
4.2 DisplayImpl
/**
* @author CSZ
*/
public abstract class DisplayImpl {
public abstract void rawOpen();
public abstract void rawPrint();
public abstract void rawClose();
}
4.3 CountDisplay
/**
* @author CSZ
*/
public class CountDisplay extends Display{
public CountDisplay(DisplayImpl impl) {
super(impl);
}
public void multiDisplay(int times){
open();
for (int i = 0; i < times; i++) {
print();
}
close();
}
}
4.4 StringDisplayImpl
/**
* @author CSZ
*/
public class StringDisplayImpl extends DisplayImpl{
private String string;
private int width;
public StringDisplayImpl(String string) {
this.string = string;
this.width = string.getBytes().length;
}
private void printLine() {
System.out.print("+");
for (int i = 0; i < width; i++) {
System.out.print("-");
}
System.out.println("+");
}
@Override
public void rawOpen() {
printLine();
}
@Override
public void rawPrint() {
System.out.println("|" + string + "|");
}
@Override
public void rawClose() {
printLine();
}
}
4.5 测试类
/**
* @author CSZ
*/
public class MainTest {
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.display();
d3.multiDisplay(3);
}
}
image.png
5. 思考与总结
我们明确了我们的任务，组织编写了某个类，他的核心作用就是 display 方法，我们最终的目的就是调用这个方法，而在这个方法中还涉及了其余的3个方法，这些都是为了最终核心方法服务的。当我们想扩展功能时，比如 CountDispaly 不满足我们的需要了，我们就可以在编写一个 anotherDispaly()，然后再Main中调用。
而通过继承抽象的 DisplayImpl 也是为了方便扩展，比如现在我对核心方法的设计有了新的想法，比如，我们感觉这个展示效果不好，我们就可以使用一个替代方案，创建一个新的 AnotherDispalyImpl 然后重写一种实现方案，便可以轻松达到替换效果。
继承是强关联的，但是委托是弱关联的。
我们可以看到，Dispaly 和 DisplayImpl 是两个独立的类，虽然我们 DisplayImpl 的创建就是为了给 Display 使用的，但并不是通过继承方式，而是通过聚合的关系，这样两个独立的类形成了一种委托的关系。委托在前文中，Template 模式中也有出现。也就是通过委托，我们的任务就可以轻松转移。
Strategy 模式
1. 场景分析
举办一场，石头剪刀布的游戏
2. UML
image.png
3. Code
3.1 Hand 表示手势
/**
* @author CSZ
*/
public class Hand {
// 实际的值
private int handValue;
// 石头
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[] HANDS = {
new Hand(HANDVALUE_GUU),
new Hand(HANDVALUE_CHO),
new Hand(HANDVALUE_PAA),
};
// 为每个手势规定名称
private static final String[] NAME = {
"石头","剪刀","布"
};
// 构造方法
private Hand(int handValue){
this.handValue = handValue;
}
// 根据值获取手势
public static Hand getHand(int handValue){
return HANDS[handValue];
}
// 如果 this 胜应该返回 1
public boolean isStrongerThan(Hand hand){
return fight(hand) == 1;
}
// 如果 this 败应该返回 -1
public boolean isWeakerThan(Hand hand){
return fight(hand) == -1;
}
/**
* 如果两者相同 平局返回 0，假设两者都是 石头 平局
* 但是 this + 1 == 石头 说明，this 是 布，所以 this 胜，此外的情况 that 胜
*/
private int fight(Hand hand){
if (this == hand){
return 0;
}else if ((this.handValue + 1) % 3 == hand.handValue){
return 1;
}else {
return -1;
}
}
@Override
public String toString() {
return NAME[handValue];
}
}
3.2 Strategy 接口
/**
* @author CSZ
*/
public interface Strategy {
// 用于出下一次动作
public abstract Hand nextHand();
// 用于计算学习
public abstract void study(boolean win);
}
3.3 根据赢了一直使用策略
/**
* @author CSZ
*/
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;
}
}
3.4 根据两次手势比重策略
/**
* @author CSZ
*/
public class ProbStrategy implements Strategy{
private Random random;
// 上次的手势
private int prevHandValue = 0;
// 本次要出的手势
private int currentHandValue = 0;
// 二维数组，第一维表示上局的手势，第二维表示这次要出的手势
// 根据上次和这次的手势，得到一个坐标点，赢了在学习时，为当前坐标点增加比重
// 输了给上次手势所在的其他坐标点增加比重
private int[][] history = {
{1,1,1,},
{1,1,1,},
{1,1,1,},
};
public ProbStrategy(int seed){
random = new Random(seed);
}
@Override
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);
}
@Override
public void study(boolean win) {
if (win){
history[prevHandValue][currentHandValue]++;
} else {
history[prevHandValue][(currentHandValue + 1) % 3]++;
history[prevHandValue][(currentHandValue + 2) % 3]++;
}
}
private int getSum(int hv){
int sum = 0;
for (int i = 0; i < 3; i++) {
sum += history[hv][i];
}
return sum;
}
}
3.5 Player
/**
* @author CSZ
*/
public class Player {
private String name;
private Strategy strategy;
private int winCount;
private int loseCount;
private int gameCount;
public Player(String name, Strategy strategy) {
this.name = name;
this.strategy = strategy;
}
public Hand nextHand(){
return strategy.nextHand();
}
public void win(){
strategy.study(true);
winCount++;
gameCount++;
}
public void lose(){
strategy.study(false);
loseCount++;
gameCount++;
}
public void even(){
gameCount++;
}
@Override
public String toString() {
return "Player{" +
"name='" + name + '\'' +
", strategy=" + strategy +
", winCount=" + winCount +
", loseCount=" + loseCount +
", gameCount=" + gameCount +
'}';
}
public String showName(){
return name;
}
}
3.6 测试类
/**
* @author CSZ
*/
public class MainTest {
public static void main(String[] args) {
int seed1 = 314;
int seed2 = 13;
Player tom = new Player("Tom", new WinningStrategy(seed1));
Player jerry = new Player("Jerry", new ProbStrategy(seed2));
for (int i = 0; i < 100; i++) {
Hand tomHand = tom.nextHand();
Hand jerryHand = jerry.nextHand();
if (tomHand.isStrongerThan(jerryHand)){
System.out.println("Winner:" + tom.showName());
tom.win();
jerry.lose();
}else if (jerryHand.isStrongerThan(tomHand)){
System.out.println("Winner:" + jerry.showName());
jerry.win();
tom.lose();
}else {
System.out.println("Even.....");
tom.even();
jerry.even();
}
}
System.out.println("Total result");
System.out.println(tom);
System.out.println(jerry);
}
}
image.png
总结与思考：
其实大家不用过于纠结实现的逻辑，虽然我也是搞了半天非要搞懂，但实际上，我们理解策略的用法即可，策略模式其实在实现上不复杂，无非是我们设定好几种策略，然后在Context 中以聚合的方式加载策略，然后根据策略使用即可，但是有个很核心的问题，这就是图中的 Context 对象的另一个作用，也就是案例中的Player，策略的意义是什么？如果理解了刚才的案例，就会发现就是 ProbStrategy 策略更科学，也更优质，那我设计好几种策略有什么用。
其实，策略为我们将算法从类中抽离了，又是利用委托的形式将我们的实现委托给了策略。但是正如算法一样，有些是利用时间换取空间，有些呢则是利用空间换取时间。没有那么完美的场景，我们想要实现的都符合我们的心意，所以，当我们希望更快响应的时候，就可以使用 时间优先策略，当我们内存不充裕的时候，我们可以使用 小容量优先，这就是策略的意义。
