• 设计模式——装饰者模式、桥接模式、外观模式（结构型模式）

    1.装饰者模式

    装饰（Decorator）模式中的角色：

    • 抽象构件（Component）角色 ：定义一个抽象接口以规范准备接收附加责任的对象。

    • 具体构件（Concrete Component）角色 ：实现抽象构件，通过装饰角色为其添加一些职责。

    • 抽象装饰（Decorator）角色 ： 继承或实现抽象构件，并包含具体构件的实例，可以通过其子类扩展具体构件的功能。

    • 具体装饰（ConcreteDecorator）角色 ：实现抽象装饰的相关方法，并给具体构件对象添加附加的责任。

    抽象构件：

    1. //快餐：抽象构件
    2. public abstract class FastFood {
    3.  
    4.     private float price;//价格
    5.     private String desc; //描述
    6.  
    7.     public float getPrice() {
    8.         return price;
    9.     }
    10.  
    11.     public void setPrice(float price) {
    12.         this.price = price;
    13.     }
    14.  
    15.     public String getDesc() {
    16.         return desc;
    17.     }
    18.  
    19.     public void setDesc(String desc) {
    20.         this.desc = desc;
    21.     }
    22.  
    23.     public FastFood(float price, String desc) {
    24.         this.price = price;
    25.         this.desc = desc;
    26.     }
    27.  
    28.     public FastFood() {
    29.     }
    30.  
    31.     public abstract float cost();//算钱
    32. }

    具体构件：

    1. //炒面：具体的构件角色
    2. public class FriedNoodles extends FastFood {
    3.  
    4.     public FriedNoodles() {
    5.         super(12,"炒面");
    6.     }
    7.  
    8.     public float cost() {
    9.         return getPrice();
    10.     }
    11. }
    12.  
    13.  
    14.  
    15. //炒饭：具体构件角色
    16. public class FriedRice extends FastFood {
    17.  
    18.     public FriedRice() {
    19.         super(10,"炒饭");
    20.     }
    21.  
    22.     public float cost() {
    23.         return getPrice();
    24.     }
    25. }

    抽象装饰：

    1.  
    2. //抽象装饰角色
    3. public abstract class Garnish extends FastFood {
    4.  
    5.     //声明快餐类的变量
    6.     private FastFood fastFood;
    7.  
    8.     //有参构造方法
    9.     public Garnish(FastFood fastFood, float price, String desc) {
    10.         super(price, desc);
    11.         this.fastFood = fastFood;
    12.     }
    13.  
    14.  
    15.     public FastFood getFastFood() {
    16.         return fastFood;
    17.     }
    18.  
    19.     public void setFastFood(FastFood fastFood) {
    20.         this.fastFood = fastFood;
    21.     }
    22.  
    23. }

    具体装饰：

    1. //鸡蛋类：具体的装饰者角色
    2. public class Egg extends Garnish {
    3.  
    4.     public Egg(FastFood fastFood) {
    5.         super(fastFood,1,"鸡蛋");
    6.     }
    7.  
    8.     public float cost() {
    9.         //计算价格
    10.         return getPrice() + getFastFood().cost();
    11.     }
    12.  
    13.     @Override
    14.     public String getDesc() {
    15.         return super.getDesc() + getFastFood().getDesc();
    16.     }
    17. }
    18.  
    19.  
    20.  
    21. //培根类：具体的装饰者角色
    22. public class Bacon extends Garnish {
    23.  
    24.     public Bacon(FastFood fastFood) {
    25.         super(fastFood,2,"培根");
    26.     }
    27.  
    28.     public float cost() {
    29.         //计算价格
    30.         return getPrice() + getFastFood().cost();
    31.     }
    32.  
    33.     @Override
    34.     public String getDesc() {
    35.         return super.getDesc() + getFastFood().getDesc();
    36.     }
    37. }

    测试类：

    1. //测试类
    2. public class Client {
    3.     public static void main(String[] args) {
    4.         //点一份炒饭
    5.         FastFood food = new FriedRice();
    6.         System.out.println(food.getDesc() + "  " + food.cost() + "元");//炒饭  10.0元
    7.  
    8.         System.out.println("===============");
    9.  
    10.         //在上面的炒饭中加一个鸡蛋
    11.         food = new Egg(food);
    12.         System.out.println(food.getDesc() + "  " + food.cost() + "元");//鸡蛋炒饭  11.0元
    13.  
    14.         System.out.println("================");
    15.         //再加一个鸡蛋
    16.         food = new Egg(food);
    17.         System.out.println(food.getDesc() + "  " + food.cost() + "元");//鸡蛋鸡蛋炒饭  12.0元
    18.  
    19.         System.out.println("================");
    20.         food = new Bacon(food);
    21.         System.out.println(food.getDesc() + "  " + food.cost() + "元");//培根鸡蛋鸡蛋炒饭  14.0元
    22.     }
    23. }

    2.桥接模式

    桥接（Bridge）模式包含以下主要角色：

    • 抽象化（Abstraction）角色 ：定义抽象类，并包含一个对实现化对象的引用。

    • 扩展抽象化（Refined Abstraction）角色 ：是抽象化角色的子类，实现父类中的业务方法，并通过组合关系调用实现化角色中的业务方法。

    • 实现化（Implementor）角色 ：定义实现化角色的接口，供扩展抽象化角色调用。

    • 具体实现化（Concrete Implementor）角色 ：给出实现化角色接口的具体实现。

    抽象化角色：

    1. //操作系统版本：抽象化角色
    2. public abstract class OperatingSystemVersion {
    3.  
    4.     protected VideoFile videoFile;
    5.  
    6.     public OperatingSystemVersion(VideoFile videoFile) {
    7.         this.videoFile = videoFile;
    8.     }
    9.  
    10.     public abstract void play(String fileName);
    11. }

    扩展抽象化角色：

    1. //Windows版本：扩展抽象化角色
    2. public class Windows extends OperatingSystemVersion {
    3.  
    4.     public Windows(VideoFile videoFile) {
    5.         super(videoFile);
    6.     }
    7.  
    8.     public void play(String fileName) {
    9.         videoFile.decode(fileName);
    10.     }
    11. }
    12.  
    13.  
    14. //mac版本：扩展抽象化角色
    15. public class Mac extends OperatingSystemVersion {
    16.  
    17.     public Mac(VideoFile videoFile) {
    18.         super(videoFile);
    19.     }
    20.  
    21.     public void play(String fileName) {
    22.         videoFile.decode(fileName);
    23.     }
    24. }

    实现化角色：

    1. //视频文件：实现化
    2. public interface VideoFile {
    3.     void decode(String fileName);
    4. }

    具体实现化角色：

    1. //avi文件：具体实现化
    2. public class AVIFile implements VideoFile {
    3.     public void decode(String fileName) {
    4.         System.out.println("avi视频文件："+ fileName);
    5.     }
    6. }
    7.  
    8. //rmvb文件：具体实现化
    9. public class REVBBFile implements VideoFile {
    10.     public void decode(String fileName) {
    11.         System.out.println("rmvb文件：" + fileName);
    12.     }
    13. }

    测试类：

    1. //测试类
    2. public class Client {
    3.     public static void main(String[] args) {
    4.         OperatingSystemVersion os = new Windows(new AVIFile());
    5.         os.play("战狼3");
    6.     }
    7. }

    使用场景

    • 当一个类存在两个独立变化的维度，且这两个维度都需要进行扩展时。

    • 当一个系统不希望使用继承或因为多层次继承导致系统类的个数急剧增加时。

    • 当一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性时。避免在两个层次之间建立静态的继承联系，通过桥接模式可以使它们在抽象层建立一个关联关系。

    3.外观模式

    外观（Facade）模式包含以下主要角色：

    • 外观（Facade）角色：为多个子系统对外提供一个共同的接口。

    • 子系统（Sub System）角色：实现系统的部分功能，客户可以通过外观角色访问它。

    子系统角色：

    1. //灯类：子系统角色
    2. public class Light {
    3.     public void on() {
    4.         System.out.println("打开了灯....");
    5.     }
    6.  
    7.     public void off() {
    8.         System.out.println("关闭了灯....");
    9.     }
    10. }
    11.  
    12. //空调类：子系统角色
    13. public class AirCondition {
    14.     public void on() {
    15.         System.out.println("打开了空调....");
    16.     }
    17.  
    18.     public void off() {
    19.         System.out.println("关闭了空调....");
    20.     }
    21. }
    22.  
    23. //电视类：子系统角色
    24. public class TV {
    25.     public void on() {
    26.         System.out.println("打开了电视....");
    27.     }
    28.  
    29.     public void off() {
    30.         System.out.println("关闭了电视....");
    31.     }
    32. }

    外观角色：

    1. //智能音箱：外观角色
    2. public class SmartAppliancesFacade {
    3.  
    4.     private Light light;
    5.     private TV tv;
    6.     private AirCondition airCondition;
    7.  
    8.     public SmartAppliancesFacade() {
    9.         light = new Light();
    10.         tv = new TV();
    11.         airCondition = new AirCondition();
    12.     }
    13.  
    14.     public void say(String message) {
    15.         if(message.contains("打开")) {
    16.             on();
    17.         } else if(message.contains("关闭")) {
    18.             off();
    19.         } else {
    20.             System.out.println("我还听不懂你说的！！！");
    21.         }
    22.     }
    23.  
    24.     //起床后一键开电器
    25.     private void on() {
    26.         System.out.println("起床了");
    27.         light.on();
    28.         tv.on();
    29.         airCondition.on();
    30.     }
    31.  
    32.     //睡觉一键关电器
    33.     private void off() {
    34.         System.out.println("睡觉了");
    35.         light.off();
    36.         tv.off();
    37.         airCondition.off();
    38.     }
    39. }

    测试类：

    1. //测试类
    2. public class Client {
    3.     public static void main(String[] args) {
    4.         //创建外观对象
    5.         SmartAppliancesFacade facade = new SmartAppliancesFacade();
    6.         //客户端直接与外观对象进行交互
    7.         facade.say("打开家电");
    8.         facade.say("关闭家电");
    9.     }
    10. }

    好处：

    • 降低了子系统与客户端之间的耦合度，使得子系统的变化不会影响调用它的客户类。

    • 对客户屏蔽了子系统组件，减少了客户处理的对象数目，并使得子系统使用起来更加容易。

    缺点：

    • 不符合开闭原则，修改很麻烦

    使用场景

    • 对分层结构系统构建时，使用外观模式定义子系统中每层的入口点可以简化子系统之间的依赖关系。

    • 当一个复杂系统的子系统很多时，外观模式可以为系统设计一个简单的接口供外界访问。

    • 当客户端与多个子系统之间存在很大的联系时，引入外观模式可将它们分离，从而提高子系统的独立性和可移植性。

  • 相关阅读:
    sql函数coalesce和parse_url
    力扣 6080. 使数组按非递减顺序排列
    代码随想录算法训练营第五十九天|647. 回文子串、 516.最长回文子序列
    机器学习中遇到的函数以及用法
    12.LoadRunner，基于html录制和基于url录制
    数据结构--平衡二叉树
    SAT Encoding and CDCL Algorithm听课笔记
    【QT开发笔记-基础篇】| 第四章 事件QEvent | 4.6 定时器事件
    heroku的使用，部署node后端
    torch lighting 为不同模型设置不同的学习率
  • 原文地址：https://blog.csdn.net/m0_63544124/article/details/126011110