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

server/2024/9/23 13:02:25/

九、Bridge模式：将类的功能层次结构与实现层次结构分离

类的两个层次结构和作用

类的功能层次结构：希望增加新功能时

父类有基本功能，在子类中增加新功能

Something父类
…├─SomethingGood子类

想要再增加新功能

Something父类
…├─SomethingGood子类
… …├─SomethingBetter子类

注：通常，类的层次结构关系不应过深

类的实现层次结构：希望增加新的实现时

回顾 Template Method模式，定义了抽象类，有多个子类实现。

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

AbstractClass抽象类
…├─ConcreteClass具体实现类
… …├─AnotherConcreteClass具体实现类

当类的层次结构只有一层时，功能层次结构与实现层次结构是混杂在一个层次结构中的。

这样很容易使类的层次结构变得复杂，难理解。因为自己难确定应该在类的哪一个层次结构中去增加子类。

因此，我们需要将“类的功能层次结构”与“类的实现层次结构”分离为两个独立的类层次结构。

如果只是简单地将它们分开，两者之间必然会缺少联系。所以我们需要Bridge模式在它们之间搭建一座桥梁。

示例程序类图

在这里插入图片描述

Display

java">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

java">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

java">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

java">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 模式中的角色。

java">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

java">public interface Strategy {// 获取下一局要出的手势。调用该方法后，实现了strategy接口的类会绞尽脑汁想出下一局出什么手势。public abstract Hand nextHand();// 学习“上一局的手势是否获胜了”，Strategy接口的实现类就会根据参数改变自己的内部状态public abstract void study(boolean win);
}

WinningStrategy

java">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

java">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

java">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

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


http://www.ppmy.cn/server/105034.html

相关文章

stm32智能颜色送餐小车（红外光管避障）

stm32智能颜色送餐小车（红外光管避障）

大家好啊&#xff0c;我是情谊&#xff0c;今天我们来介绍一下我最近设计的stm32产品&#xff0c;我们在今年七月份的时候参加了光电设计大赛&#xff0c;我们小队使用的就是stm32的智能送餐小车&#xff0c;虽然止步于省赛&#xff0c;但是还是一次成长的经验吧&#xff0c;那…
阅读更多...
基于UE5和ROS2的激光雷达+深度RGBD相机小车的仿真指南(三)---创建自定义激光雷达Componet组件

基于UE5和ROS2的激光雷达+深度RGBD相机小车的仿真指南(三)---创建自定义激光雷达Componet组件

前言 本系列教程旨在使用UE5配置一个具备激光雷达深度摄像机的仿真小车&#xff0c;并使用通过跨平台的方式进行ROS2和UE5仿真的通讯&#xff0c;达到小车自主导航的目的。本教程默认有ROS2导航及其gazebo仿真相关方面基础&#xff0c;Nav2相关的学习教程可以参考本人的其他博…
阅读更多...
【Linux网络】select函数

【Linux网络】select函数

欢迎来到 破晓的历程的 博客 ⛺️不负时光&#xff0c;不负己✈️ 文章目录 select函数介绍select函数参数介绍select函数返回值select的工作流程TCP服务器【多路复用版】 select函数介绍 在Linux网络编程中&#xff0c;select 函数是一种非常有用的IO多路复用技术&#xff0…
阅读更多...
C++ | Leetcode C++题解之第371题两整数之和

C++ | Leetcode C++题解之第371题两整数之和

题目&#xff1a; 题解&#xff1a; class Solution { public:int getSum(int a, int b) {while (b ! 0) {unsigned int carry (unsigned int)(a & b) << 1;a a ^ b;b carry;}return a;} };
阅读更多...
大数据开发工程师面试整理-系统设计

大数据开发工程师面试整理-系统设计

系统设计是软件工程中的关键环节，尤其是在处理大规模分布式系统和大数据平台时，系统设计需要考虑多个方面，包括系统的可扩展性、可靠性、性能、安全性等。以下是系统设计的一些核心原则和常见的设计步骤，以及在大数据环境下的具体应用场景： 1. 核心设计原则 ● 可扩展性（…
阅读更多...
代码随想录算法训练营_day24

代码随想录算法训练营_day24

题目信息 93. 复原 IP 地址 题目链接: https://leetcode.cn/problems/restore-ip-addresses/description/ 题目描述: 有效 IP 地址 正好由四个整数&#xff08;每个整数位于 0 到 255 之间组成&#xff0c;且不能含有前导 0&#xff09;&#xff0c;整数之间用 . 分隔。 例如…
阅读更多...
数据库性能指标及数据要素构架设计

数据库性能指标及数据要素构架设计

数据库性能指标及数据要素构架 一、引言在当今数字化时代&#xff0c;金融行业高度依赖信息技术来处理大量的敏感数据和进行复杂的交易操作。数据库作为金融机构核心的数据存储和管理系统&#xff0c;其性能和数据要素构架的合理性直接关系到金融业务的高效运行、数据安全以及决…
阅读更多...
Python | Leetcode Python题解之第371题两整数之和

Python | Leetcode Python题解之第371题两整数之和

题目&#xff1a; 题解&#xff1a; MASK1 4294967296 # 2^32 MASK2 2147483648 # 2^31 MASK3 2147483647 # 2^31-1class Solution:def getSum(self, a: int, b: int) -> int:a % MASK1b % MASK1while b ! 0:carry ((a & b) << 1) % MASK1a (a ^ b) % MA…
阅读更多...
最新文章

Copyright @ 2022~2023