【23种设计模式应用场景汇总】

23种设计模式应用场景汇总


23种设计模式

设计模式是一种在软件开发中解决特定问题的通用解决方案。下面我将尝试将23种设计模式融入到一个场景中：
假设我们正在开发一个在线购物系统，我们可以使用以下设计模式：

  • 1. 工厂方法模式：当用户在网站上下订单时，我们可以使用工厂方法模式来创建订单对象，根据用户选择的商品类型，使用不同的工厂来创建相应的订单对象。

分为：工厂模式分为：简单工厂、工厂方法、抽象工厂。
1、简单工厂通过参数决定创建哪个实例、
2、工厂方法将工厂、产品提出抽象接口、每一种产品对应一个工厂，最后根据用户的参数，使用不同的工厂创建不同的产品实例。
3、抽象工厂：是一个工厂创建一系列产品(比如windos上的GUI组件：windows版本的按钮、文本框、选择按钮等，是与linux或MacOs下的不同)。产品1(A系列产品1、B系列产品2)，产品2(A系统产品2、B系列产品2)，工厂(A系列工厂、B系列工厂)，A工厂就会创建A系列产品1、A系列产品2；B工厂创建B系列产品1、B系列产品2.

  • 2. 单例模式：我们可以使用单例模式来确保系统中的购物车对象只有一个实例，以确保用户在整个会话期间都使用同一个购物车。

懒汉式和饿汉式。五种，最重要的是线程安全。

  • 3. 观察者模式：当用户下订单时，我们可以使用观察者模式通知库存管理系统和仓库系统更新库存。这样，一旦有商品被下单，其他系统就会及时得到通知。

观察者模式

  1. java中提供了类Observable，只需要继承此类即可将子类变成Subject(被观察者)
  2. 被观察者持有观察者的引用，所以subject的状态发生变化后，就可以通知到观察者
  3. 观察者需要实现Observer, 重写update方法。
  • 4. 策略模式：在计算订单总价时，我们可以根据用户的会员等级或者促销活动来选择不同的计价策略，这就是策略模式的应用。
  1. 具体的角色有: strategy(一个抽象类或接口)
  2. 具体策略ConcreteStrategy(提供不同的算法)
  3. 环境角色：context 持有策略的引用，负责根据在运行时的需求选择并设置具体的策略对象。与客户端进行交互，通过使用策略对象执行相应的操作或计算。
  • 5. 适配器模式：当我们需要将外部支付f接口整合到系统中时，我们可能需要使用适配器模式来将外部接口适配成我们系统内部的统一接口。

三个角色：Target目标类、源Adaptee、适配器Adapter

  1. 目标角色定义了客户端所期待的接口，也就是客户程序需要调用的方法。它是适配器要转换到的目标接口
  2. 源角色是现有的接口或实现类，它拥有需要被适配的功能，但其接口与目标不兼容。
  3. 适配器角色实现了目标接口，并持有对源对象的引用，负责将源对象的接口转换为与目标接口兼容的形式。
    适配器模式的关键在于，通过创建一个适配器类来解决现有类与期望接口之间的不匹配问题，使得原本由于接口不兼容而无法协同工作的两个系统可以协同工作。

分类: 在具体实现中，适配器模式可以分为两种类型

  • 类适配器：适配器类继承自源角色，并实现目标接口，所以适配器既可以调用源角色的方法，又能提供目标接口要求的方法。
  • 对象适配器：适配器类实现目标接口，并持有一个源对象实例作为成员变量，通过调用源对象的方法来完成目标接口的实现
  • 6. 装饰者模式：如果我们需要在订单中加入礼品包装、贺卡等功能，可以使用装饰者模式动态地为订单对象添加额外的功能。

装饰者功能：

  1. 扩展功能：当需要向现有的类中添加新的行为或职责时，尤其是不能直接修改原始类的源代码的情况下，可以使用装饰者模式动态地将新功能附加到对象上。
  2. 灵活组合出各种特性的对象：通过不同的装饰者排列组合，可以构建出不同特性的对象，实现多种功能的可插拔式组合。
  3. 装饰者对象与被装饰的对象具有相同的超类型，客户端程序无需知道是否进行了装饰以及如何装饰的细节，只需面向统一的接口进行操作即可。

角色：

  1. component：定义了一个对象接口，可以给这些对象动态添加职责。
  2. ConcreteComponent：具体的原始组件对象，实现了Component接口。
  3. Decorator： 抽象装饰者类，继承自Component，从外类扩展Component类的功能，维持了与Component相同的接口。
  4. ConcreteDecorator：具体装饰类，实现了Decorator接口，并维持对Component对象的引用，在其方法中既可以调用原始对象的方法，也可以增加额外的操作。
  • 7. 命令模式：在处理用户的退货请求时，我们可以使用命令模式将用户的退货请求封装成命令对象，然后由相应的命令对象来执行具体的退货操作。

角色分类：

  1. 调用者/请求者(Invoker)
  2. 抽象命令(Command)和具体命令(concreteCommand)
  3. 接收者(Receiver)
  4. 客户端Client


调用链：       客户端 ——> 调用者 ——> 命令——> 接受者

  • 8. 模板方法模式：在生成订单报告时，我们可以使用模板方法模式定义生成报告的流程，然后在具体的报告生成类中实现具体的步骤。

角色：

  1. 抽象类(Abstract Class/Template Class)
    * 定义了一个或多个抽象操作方法，用于子类去实现。同时定义了一个或多个具体方法(通常包括一个或多个框架方法)，这些方法可以是一个完整的算法骨架，包含了整个算法的固定步骤。
  2. 具体子类(concrete subClass)
    实现了抽象类中所声 明的抽象操作。每个子类提供了一种不同的算法实现方式。
    子类在实现抽象方法时填充模版方法预留的"空洞"，从而完成特定的业务逻辑。

功能：

  • 模版方法模式通过将不变的行为（即模版方法）放在抽象类中，并将可变的行为（即抽象方法）留给子类去实现，实现了代码复用和对算法结构的控制。子类可以在不改变算法整体结构的前提下，重新定义部分步骤，以适应不同的应用场景。
  • 9. 原型模式：在系统中有一些商品是定制化的，我们可以使用原型模式来克隆商品对象，以便快速创建定制化商品的副本。

角色分类：

  1. 抽象原型类(prototype Interface/Abstract Prototype class)
    定义了一个克隆自身的接口，通常包含一个clone()方法，它是所有具体原型类必须实现的方法。
  2. 具体原型类(Concrete Prototype Class)
    实现了抽象原型类所声明的clone()方法，该方法可以创建并返回一个新的对象实例，这个新实例是当前对象的一个深拷贝或者浅拷贝。
    具体原型类包含了定义对象状态的所有必要属性和行为。
  3. 客户端(Client)
    创建并使用具体原型类的对象，通过调用原型对象的clone()方法来复制出新的对象实例，而不是直接通过new关键字创建新对象。
  • 10. 抽象工厂模式：如果我们的系统需要支持多个不同类型的支付方式（比如信用卡、支付宝、微信支付等），我们可以使用抽象工厂模式来创建不同支付方式的工厂，从而实现一个统一的支付接口。
  • 11. 建造者模式：当用户在网站上定制礼篮时，我们可以使用建造者模式来创建复杂的礼篮对象，将其构建过程与表示分离，使得构建过程可以创建不同的表示。

角色：

  1. 抽象建造者：
    – 定义了一个创建产品的接口，声明了一系列用于构建产品对象的方法。这些方法通常按特定的顺序调用以逐步构造整个产品对象。
  2. 具体建造者:
    – 实现了抽象建造者接口，并提供构造和装配产品的各个部件的具体实现。在建造过程完成后，它还提供了获取最终产品的接口或方法。
  3. 产品：
    – 是建造者模式所要创建的对象类型。可以是一个复杂的对象，包含多个属性或者子组件。
  4. 导演者/指挥者(Director):
    – 负责控制建造过程，协调各个步骤的执行顺序。它可以独立于具体建造者角色而变化，不依赖于具体的构建细节。
    指挥者 ——> 建造者 ——> 产品
/**
 示例代码
 作者: LeKu_yuan
*/
// 1. 抽象建造者
public abstract class AbstractComputerBuilder {
    protected Computer computer = new Computer();

    public abstract void buildCPU();
    public abstract void buildMemory();
    public abstract void buildHardDrive();

    // 返回最终产品
    public Computer getComputer() {
        return computer;
    }
}

// 2. 具体建造者
public class HighPerformanceComputerBuilder extends AbstractComputerBuilder {
    @Override
    public void buildCPU() {
        computer.setCpu("Intel Core i9");
    }

    @Override
    public void buildMemory() {
        computer.setMemory("64GB DDR5 RAM");
    }

    @Override
    public void buildHardDrive() {
        computer.setHardDrive("2TB SSD");
    }
}

// 3. 产品
public class Computer {
    private String cpu;
    private String memory;
    private String hardDrive;

    public String getCpu() {
        return cpu;
    }

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public String getMemory() {
        return memory;
    }

    public void setMemory(String memory) {
        this.memory = memory;
    }

    public String getHardDrive() {
        return hardDrive;
    }

    public void setHardDrive(String hardDrive) {
        this.hardDrive = hardDrive;
    }

    @Override
    public String toString() {
        return "Computer{" +
                "cpu='" + cpu + '\'' +
                ", memory='" + memory + '\'' +
                ", hardDrive='" + hardDrive + '\'' +
                '}';
    }
}

// （4. 可选角色）导演者/指挥者
public class Director {
    private AbstractComputerBuilder builder;

    public Director(AbstractComputerBuilder builder) {
        this.builder = builder;
    }

    public Computer constructComputer() {
        builder.buildCPU();
        builder.buildMemory();
        builder.buildHardDrive();
        return builder.getComputer();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Director director = new Director(new HighPerformanceComputerBuilder());
        Computer highPerformanceComputer = director.constructComputer();
        System.out.println(highPerformanceComputer);
    }
}
  • 12. 状态模式：在订单处理流程中，订单可能会经历多个状态（比如待支付、已支付、已发货、已签收等），我们可以使用状态模式来管理订单的状态转换，使状态转换更加清晰和可维护。

角色:

  1. 抽象状态类：定义所有具体状态角色需要实现的接口或抽象类
  2. 具体状态类：实现抽象状态角色所定义的接口，即为系统可能处于的各种状态提供具体的实现。
  3. 上下文：也称为上下文，是使用状态模式的类，它维护一个指向当前状态对象的引用
abstract class TrafficLightState {
   protected TrafficLight trafficLight;
   public void setTrafficLight(TrafficLight trafficLight) {
       this.trafficLight = trafficLight;
   }
   
   // 抽象方法，由具体状态实现
   public abstract void turnOn();
   public abstract void turnOff();
   public abstract void changeToNextState();
   
}

 // 具体状态角色（Concrete State）
class RedLightState extends TrafficLightState {
    @Override
    public void turnOn() {
        System.out.println("红灯亮起");
    }

    @Override
    public void turnOff() {
        System.out.println("红灯熄灭");
    }
    
    @Override
    public void changeToNextState() {
        trafficLight.setState(trafficLight.getYellowLightState());
    }
}

class YellowLightState extends TrafficLightState {
   @Override
   public void turnOn() {
       System.out.println("黄灯亮起");
   }

   @Override
   public void turnOff() {
       System.out.println("黄灯熄灭");
   }

   @Override
   public void changeToNextState() {
       trafficLight.setState(trafficLight.getGreenLightState());
   }
}

class GreenLightState extends TrafficLightState {
   @Override
   public void turnOn() {
       System.out.println("绿灯亮起");
   }

   @Override
   public void turnOff() {
       System.out.println("绿灯熄灭");
   }

   @Override
   public void changeToNextState() {
       trafficLight.setState(trafficLight.getRedLightState());
   }
}

 // 环境角色（Context）
public class TrafficLight {
   private TrafficLightState currentState;

   public TrafficLight() {
       currentState = new RedLightState();
       currentState.setTrafficLight(this);
   }

   public TrafficLightState getRedLightState() {
       return new RedLightState();
   }

   public TrafficLightState getYellowLightState() {
       return new YellowLightState();
   }

   public TrafficLightState getGreenLightState() {
       return new GreenLightState();
   }

   public void setState(TrafficLightState state) {
       currentState = state;
       currentState.turnOn();
   }

   public void changeLights() {
       currentState.changeToNextState();
   }
}

// 使用示例
public class Main {
   public static void main(String[] args) {
       TrafficLight trafficLight = new TrafficLight();
       trafficLight.changeLights();  // 输出：红灯亮起
       trafficLight.changeLights();  // 输出：黄灯亮起
       trafficLight.changeLights();  // 输出：绿灯亮起
       trafficLight.changeLights();  // 输出：红灯亮起
   }
}
  • 13. 桥接模式：如果我们需要在不同的平台上展示商品信息（比如网站、移动端、微信小程序等），我们可以使用桥接模式将平台和商品信息的展示进行解耦，从而让它们可以独立地变化。

桥接模式(Bridge Pattern)是一种结构设计模式，它将抽象部分与它的实现部分分离，使它们都可以独立地变化。

角色：

  1. 抽象化角色(Abstraction)： 这是抽象类，定义了抽象接口，维护一个对实现化角色的引用。与客户端进行交互
  2. 扩展抽象化角色（Refined Abstraction): 这是抽象化角色的子类，可以提供额外的功能和方法，或者修改从抽象化继承的方法行为，但仍然包含对实现化角色的引用。
  3. 实现化角色（Implementor)：
    这是一个接口或抽象类，定义了实现化角色需要实现的一组接口方法。
    实现化角色不依赖于抽象化角色，它定义了实现功能的具体结构和算法
  4. 具体实现化角色（Concrete Implementor）
    这是实现化角色的具体实现类，实现了接口或抽象类定义的所有方法，为抽象化角色提供了具体的实现方案。

总结: 将两个变化的因素分割开，利用笛卡尔积使其组合，而不是创建笛卡尔积个类模版。

例子: 比如形状和颜色，不同的形状需要不同的颜色，这个可以分开。

//  **代码演示**:
// 实现化角色（Implementor）
interface ColorStrategy {
    void applyColor();
}

// 具体实现化角色（Concrete Implementor）
class RedColorStrategy implements ColorStrategy {
    @Override
    public void applyColor() {
        System.out.println("应用红色填充");
    }
}

class GreenColorStrategy implements ColorStrategy {
    @Override
    public void applyColor() {
        System.out.println("应用绿色填充");
    }
}

// 抽象化角色（Abstraction）
abstract class Shape {
    protected ColorStrategy color;

    public Shape(ColorStrategy color) {
        this.color = color;
    }

    public abstract void draw();

    public void setColor(ColorStrategy color) {
        this.color = color;
    }
}

// 扩展抽象化角色（Refined Abstraction）
class Circle extends Shape {
    public Circle(ColorStrategy color) {
        super(color);
    }

    @Override
    public void draw() {
        System.out.println("绘制圆形...");
        color.applyColor(); // 应用颜色填充策略
    }
}

class Square extends Shape {
    public Square(ColorStrategy color) {
        super(color);
    }

    @Override
    public void draw() {
        System.out.println("绘制正方形...");
        color.applyColor(); // 应用颜色填充策略
    }
}

// 使用示例
public class BridgePatternDemo {
    public static void main(String[] args) {
        Shape circle1 = new Circle(new RedColorStrategy());
        Shape square1 = new Square(new GreenColorStrategy());

        circle1.draw();  // 输出：绘制圆形... 应用红色填充
        square1.draw();   // 输出：绘制正方形... 应用绿色填充

        circle1.setColor(new GreenColorStrategy());
        square1.setColor(new RedColorStrategy());

        circle1.draw();  // 输出：绘制圆形... 应用绿色填充
        square1.draw();   // 输出：绘制正方形... 应用红色填充
    }
}
  • 14. 组合模式：在管理商品分类树的时候，我们可以使用组合模式来表示商品分类和子分类的层次结构，以便对整个分类树进行统一的操作。

角色：

  1. Component（抽象构件）：定义了所有组件（包括叶子组件和容器组件）共享的接口。这些方法可能包括添加、删除子组件，以及一些针对整个组件树的通用操作。
  2. Leaf（叶子构件）：表示组合结构中的叶节点对象，其没有子节点。实现了 Component 接口，并提供了相应的业务逻辑。
  3. Composite（容器构件）：定义了有子节点的组合对象，同样实现 Component 接口，并提供管理子组件的方法。容器构件可以包含零个或多个其他 Component 对象。

总结：

  • 通过组合模式的应用，可以让用户对单个对象和复合对象的使用具有统一性和一致性，同时能够灵活地遍历整个结构并对每个元素进行相同的操作处理。
// 抽象构件（Component）
interface FileSystemObject {
    void add(FileSystemObject obj);
    void remove(FileSystemObject obj);
    void display(int depth);
}

// 叶子构件（Leaf）
class File implements FileSystemObject {
    private String name;

    public File(String name) {
        this.name = name;
    }

    @Override
    public void add(FileSystemObject obj) {
        throw new UnsupportedOperationException("Files cannot contain other objects");
    }

    @Override
    public void remove(FileSystemObject obj) {
        throw new UnsupportedOperationException("Files cannot contain other objects");
    }

    @Override
    public void display(int depth) {
        for (int i = 0; i < depth; i++) {
            System.out.print("-");
        }
        System.out.println(name);
    }
}

// 容器构件（Composite）
class Directory implements FileSystemObject {
    private List<FileSystemObject> children;
    private String name;

    public Directory(String name) {
        this.name = name;
        this.children = new ArrayList<>();
    }

    @Override
    public void add(FileSystemObject obj) {
        children.add(obj);
    }

    @Override
    public void remove(FileSystemObject obj) {
        children.remove(obj);
    }

    @Override
    public void display(int depth) {
        for (int i = 0; i < depth; i++) {
            System.out.print("-");
        }
        System.out.println(name);

        for (FileSystemObject child : children) {
            child.display(depth + 1);
        }
    }
}

// 使用示例
public class CompositePatternDemo {
    public static void main(String[] args) {
        Directory root = new Directory("Root");
        Directory dir1 = new Directory("Dir1");
        Directory dir2 = new Directory("Dir2");
        File file1 = new File("File1.txt");
        File file2 = new File("File2.txt");

        root.add(dir1);
        root.add(dir2);
        dir1.add(file1);
        dir2.add(file2);

        root.display(0);
    }
}
  • 15. 迭代器模式：当需要遍历购物车中的商品列表时，我们可以使用迭代器模式来提供一种统一的方式来遍历不同类型的购物车。
  • 16. 访问者模式：如果需要对不同类型的商品进行不同的操作（比如打印、计算价格等），我们可以使用访问者模式来实现对商品的不同操作，而不需要修改商品类的代码。

角色：

  1. Element（元素接口）：声明接受访问者对象的 accept() 方法，这是所有需要被访问的对象必须实现的接口。
  2. ConcreteElement（具体元素）：实现了 Element 接口的具体元素类，它们可以是多种不同的业务>对象，每个类都提供 accept() 方法，并且可能有各自不同的内部结构和状态。
  3. Visitor（访问者接口）：声明了对每一个 ConcreteElement 的访问操作，通常以方法的形式存在，每一个方法对应一种具体的元素类型。
  4. ConcreteVisitor（具体访问者）：实现了 Visitor 接口的具体访问者类，为每个 visit() 方法提供了具体的实现，从而定义了针对不同元素的操作逻辑。
  5. ObjectStructure（对象结构）：能够存储并遍历元素集合，它可以是一个容器或者一个复合对象，提供一个方法来允许访问者访问它的元素。

总结：

  • 使用访问者模式的一个典型场景是在一个对象结构中执行某种特定操作，但又不想让这些操作侵入到各个元素类中。例如，在编译器的不同阶段（语法分析、语义分析等），对AST（抽象语法树）节点进行操作时，就可以采用访问者模式。
  • 数据结构与操作分离、避免操作入侵数据
// Element 接口
interface Animal {
    void accept(AnimalOperation operation);
}

// ConcreteElement 类
class Lion implements Animal {
    @Override
    public void accept(AnimalOperation operation) {
        operation.visit(this);
    }
    
    // 其他 Lion 类相关的方法...
}

class Elephant implements Animal {
    @Override
    public void accept(AnimalOperation operation) {
        operation.visit(this);
    }
    
    // 其他 Elephant 类相关的方法...
}

// Visitor 接口
interface AnimalOperation {
    void visit(Lion lion);
    void visit(Elephant elephant);
}

// ConcreteVisitor 类
class FeedVisitor implements AnimalOperation {
    @Override
    public void visit(Lion lion) {
        System.out.println("Feeding the lion");
    }

    @Override
    public void visit(Elephant elephant) {
        System.out.println("Feeding the elephant");
    }
}

class CleanVisitor implements AnimalOperation {
    @Override
    public void visit(Lion lion) {
        System.out.println("Cleaning the lion's habitat");
    }

    @Override
    public void visit(Elephant elephant) {
        System.out.println("Cleaning the elephant's habitat");
    }
}

// ObjectStructure
class Zoo {
    private List<Animal> animals;

    public void addAnimal(Animal animal) {
        animals.add(animal);
    }

    public void performOperation(AnimalOperation operation) {
        for (Animal animal : animals) {
            animal.accept(operation);
        }
    }
}

// 使用示例
public class VisitorPatternDemo {
    public static void main(String[] args) {
        Zoo zoo = new Zoo();
        zoo.addAnimal(new Lion());
        zoo.addAnimal(new Elephant());

        AnimalOperation feedVisitor = new FeedVisitor();
        zoo.performOperation(feedVisitor); 

        AnimalOperation cleanVisitor = new CleanVisitor();
        zoo.performOperation(cleanVisitor);
    }
}
  • 17. 备忘录模式：在用户进行购物车操作时，我们可以使用备忘录模式来保存购物车的状态，以便用户可以在需要时恢复到之前的状态。

备忘操作需要：操作人、备忘的对象(内容、数据)、备忘薄

角色：

  1. Originator（发起对象）
  2. Memento（备忘录）
  3. Caretaker（负责对象）

好处:
利用其他扩展恢复数据，而不是增加本身的复杂性。

  • 18. 解释器模式：如果我们需要实现一些复杂的促销规则或者查询条件，可以使用解释器模式来定义一个解释器，用于解释和执行这些规则或者条件。

角色：

  1. AbstractExpression（抽象表达式）：
    这是所有具体表达式的基类或者接口，声明了一个抽象的解释方法 interpret()。
    具体的解释操作由子类实现。
  2. TerminalExpression（终结符表达式）：
    终结符表达式是文法中的原子元素，通常对应于文法中的基本符号或关键字。
    实现了 AbstractExpression 接口，并为特定的终结符提供了解释逻辑。
  3. NonterminalExpression（非终结符表达式）：
    非终结符表达式通常是更复杂的表达式结构，它们可能包含其他表达式（包括终结符和非终结符）。
    同样实现了 AbstractExpression 接口，其解释方法可能根据包含的子表达式进行递归调用以完成复杂表达式的解释过程。
  4. Context（上下文环境）：
    上下文环境角色包含了解释过程中需要的所有全局信息，比如变量、状态等，可以被各个表达式访问并影响它们的解释结果。
    有时上下文环境会作为参数传递给表达式解释方法，或者作为表达式对象的一个成员变量。
  • 19. 中介者模式：当订单系统、库存系统和物流系统之间需要进行协作时，我们可以使用中介者模式来将它们的交互行为封装到中介者对象中，从而降低系统中各个对象之间的耦合度。

预览：

  • 中介者模式（Mediator Pattern）是一种行为设计模式，它通过引入一个中介对象来封装一系列的对*象交互
    角色：
  1. AbstractMediator（抽象中介者）：
    抽象中介者定义了与各个同事对象通信的接口，通常会包含一组方法，这些方法用于注册同事对象、通知同事对象以及处理它们之间的交互请求。
    抽象中介者定义了同事类之间交互的抽象规则，允许具体中介者来实现这些交互逻辑。
  2. ConcreteMediator（具体中介者）：
    具体中介者实现了抽象中介者所声明的接口，并且负责协调和管理同事对象之间的交互。
    具体中介者了解并存储其同事对象的引用，并根据需要调用它们的方法以响应来自其他同事对象的请求或事件。
  3. Colleague（同事类）：
    同事类是参与交互的对象，它们拥有对中介者的引用，并通过中介者进行相互通信，而不是直接与其他同事类通信。
    同事类可以将消息发送给中介者，并可能通过中介者接收到来自其他同事类的消息。
  • 20. 外观模式：当需要为客户端提供一个统一的接口来访问子系统中的一群接口时，可以使用外观模式来简化客户端与子系统之间的交互。

总结:

  • 外观模式（Facade Pattern）是一种结构设计模式，它为子系统中的一组接口提供了一个统一的、更高级别的接口。通过这个简化后的接口，客户端可以更方便地与子系统交互，而无需了解子系统的复杂内部实现细节。

角色：

  1. Facade（外观类）：
  • 提供了一个更高层次的接口，该接口对子系统中的多个类进行封装和整合。
    外观类通常包含对子系统对象的引用，并定义一组方法来调用这些子系统的功能。
    客户端只需要与外观类交互，就可以完成对整个子系统的操作。
  1. Subsystem Classes（子系统类）：
  • 子系统类是实际负责执行任务的对象或组件，它们共同构成了子系统。
    子系统类通常有复杂的内部结构和相互依赖关系，但这些细节对于外观类以及使用外观类的客户端来>说都是透明的
// 子系统类（Subsystem Classes）
interface MediaPlayer {
    void play();
}

interface CDPlayer extends MediaPlayer {
    void insertCD(String cdTitle);
    void ejectCD();
}

interface Tuner {
    void turnOn();
    void setFrequency(int frequency);
    void turnOff();
}

interface Amplifier {
    void on();
    void off();
    void setStereoSound();
    void setSurroundSound();
    void setVolume(int level);
}

class CDPlayerImpl implements CDPlayer {
    @Override
    public void insertCD(String cdTitle) {
        // 实现插入CD的操作
    }

    @Override
    public void ejectCD() {
        // 实现弹出CD的操作
    }

    @Override
    public void play() {
        // 实现播放CD的操作
    }
    
    // 其他相关方法...
}

// 同样实现其他子系统类如TunerImpl、AmplifierImpl等...

// 外观类（Facade）
class HomeTheaterFacade {
    private CDPlayer cdPlayer;
    private Tuner tuner;
    private Amplifier amplifier;

    public HomeTheaterFacade(CDPlayer cdPlayer, Tuner tuner, Amplifier amplifier) {
        this.cdPlayer = cdPlayer;
        this.tuner = tuner;
        this.amplifier = amplifier;
    }

    public void playCD(String cdTitle) {
        cdPlayer.insertCD(cdTitle);
        cdPlayer.play();
        amplifier.on();
        amplifier.setStereoSound();
        tuner.turnOn();
        tuner.setFrequency(99.1);  // 设置FM调频频率
    }

    public void stop() {
        cdPlayer.stop();
        tuner.turnOff();
        amplifier.off();
    }

    // 其他组合操作方法...
}

// 示例用法
public class FacadePatternDemo {
    public static void main(String[] args) {
        CDPlayer cdPlayer = new CDPlayerImpl();
        Tuner tuner = new TunerImpl();
        Amplifier amplifier = new AmplifierImpl();

        HomeTheaterFacade homeTheater = new HomeTheaterFacade(cdPlayer, tuner, amplifier);

        homeTheater.playCD("My Favorite Album");  // 简单地调用一个方法即可启动整个音乐播放流程
    }
}
  • 21. 代理模式：在系统中，我们可以使用代理模式来控制对敏感信息的访问，比如用户的个人信息，可以通过代理对象来进行访问控制。

角色：

  1. Subject 抽象主题角色：这是一个接口或者抽象类，声明了真实主题和代理主题共同的方法
  2. RealSubject（真实主题角色）：也称为“被代理角色”，它是代理所代表的真实对象。
  3. Proxy（代理角色）：
  • 代理实现了与真实主题相同的接口（即 Subject），并可以附加额外的功能，如预处理请求、延迟加载、权限控制等。
  • 代理维护对真实主题的引用，在适当时机调用真实主题的方法来执行实际任务。
  • 在某些情况下，代理可能会对客户端请求进行拦截、过滤或增强后转发给真实主题。
  1. Client（客户端)
  • 客户端通过 Subject 接口与代理或真实主题交互，无需关心与之交互的对象是代理还是真实主题。

总结

  • 代理模式的核心思想是通过引入代理对象来间接访问目标对象，从而在访问过程中添加额外的操作或控制。这种模式在软件开发中有广泛应用，比如数据库连接池、远程服务调用、缓存代理、日志记录代理、权限控制代理等等。
  • 关注一下JDK动态代理(基于反射)和CGLIB代理(基于字节码技术)
  • 22. 责任链模式：当系统中需要处理一系列的请求，并且每个请求可能由不同的处理者来处理时，可以使用责任链模式来实现请求的传递和处理。

角色：

  1. 抽象处理这Handler:
    • 定义了一个处理请求的接口，通常包含一个或多个方法来处理请求。
    • 通常会定义一个setNextHandler()方法用于将下一个处理者对象链接起来形成链式结构，并且包含一个对下一个处理者的引用。
    • 可能还包含一个抽象的或通用的处理请求的方法，比如handleRequest(Request request)。
  2. ConcreteHandler（具体处理者）
    • 继承自抽象处理者并实现了处理请求的方法。
    • 每个具体处理者在其内部决定是否能够处理当前请求。如果可以处理，则执行相应的逻辑；如果不可以处理，则通过调用其内部持有的下一个处理者的相同方法，将请求传递给下一个节点。
  3. Request（请求）：
    • 请求对象封装了客户端发出的具体请求信息，它会被沿着责任链传递
  4. Client（客户端)
    • 创建责任链，并向链中的第一个处理者提交请求
    • 客户端并不关心请求是如何被处理和在链中如何传递的，它只需要知道请求最终会被合适的处理者处理即可。
// 请求对象（Request）
class LeaveRequest {
    private String employeeName;
    private int leaveDays;

    public LeaveRequest(String employeeName, int leaveDays) {
        this.employeeName = employeeName;
        this.leaveDays = leaveDays;
    }

    // 其他获取属性的方法...

    @Override
    public String toString() {
        return "Leave Request from " + employeeName + " for " + leaveDays + " days";
    }
}

// 抽象处理者（Handler）
abstract class Approver {
    protected Approver nextApprover;  // 对下一个处理者的引用

    public void setNextApprover(Approver approver) {
        this.nextApprover = approver;
    }

    public abstract void processRequest(LeaveRequest request);
}

// 具体处理者（ConcreteHandler）
class Manager extends Approver {
    @Override
    public void processRequest(LeaveRequest request) {
        if (request.getLeaveDays() <= 3) {  // 假设经理可以审批3天以内的假期
            System.out.println("Manager approved the request: " + request);
        } else if (nextApprover != null) {
            nextApprover.processRequest(request);  // 将请求转发给上级领导
        } else {
            System.out.println("No one can approve this request.");
        }
    }
}

class Director extends Approver {
    @Override
    public void processRequest(LeaveRequest request) {
        if (request.getLeaveDays() <= 10) {  // 假设总监可以审批10天以内的假期
            System.out.println("Director approved the request: " + request);
        } else if (nextApprover != null) {
            nextApprover.processRequest(request);  // 转发给更高级别的领导
        } else {
            System.out.println("No one can approve this request.");
        }
    }
}

// 客户端（Client）
public class ChainOfResponsibilityDemo {
    public static void main(String[] args) {
        Manager manager = new Manager();
        Director director = new Director();

        manager.setNextApprover(director);  // 构建责任链

        LeaveRequest request1 = new LeaveRequest("Employee A", 2);
        LeaveRequest request2 = new LeaveRequest("Employee B", 5);
        LeaveRequest request3 = new LeaveRequest("Employee C", 15);

        manager.processRequest(request1);  // 经理审批
        manager.processRequest(request2);  // 经理不能审批，转给总监
        manager.processRequest(request3);  // 经理和总监都不能审批
    }
}
  • 23. 享元模式：电商系统通常需要管理大量商品，每个商品可能有多个属性和规格（比如颜色、尺码等），而这些属性和规格可能是可以共享的。

预览:

  • 享元模式（Flyweight Pattern）是一种结构型设计模式，其主要目的是通过共享已经存在的对象来大幅度减少创建大量相似对象所消耗的内存资源。

角色：

  1. Flyweight 抽象享元类：
    • 定义了所有具体享元类需要实现的公共接口。这个接口通常包含了可以共享的部分状态和方法。
  2. ConcreteFlyweight具体享元类：
  3. UnsharedConcreteFlyweight 不可共享的享元类：
    • 在某些情况下，不是所有的享元都可以共享。这种类不参与共享池的管理，每个实例都包含独特的信息，不能被其他对象共享。
  4. FlyweightFactory 享元工厂： 负责创建和管理享元对象，确保合理的享元对象复用。
  5. Client：
    • 使用享元对象的外部状态，并通过享元工厂获取所需的具体享元对象。
    • 客户端并不直接创建具体的享元对象，而是通过享元工厂间接访问它们

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/326418.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

云贝教育 |【OceanBase】OBCA认证考试预约流程

云贝教育 |【OceanBase】OBCA认证考试预约流程

一、OBCA账号登录/注册&#xff0c;链接 https://www.oceanbase.com/ob/login/mobile?gotohttps%3A%2F%2Fwww.oceanbase.com%2Ftraining%2Fdetail%3Flevel%3DOBCA 注册完之后&#xff0c;请点击右上“登录”进行实名认证 OBCA考试报名链接&#xff1a;https://www.oceanbase.…
阅读更多...
IDEA2023的激活与安装（全网最靠谱，最快捷的方式）

IDEA2023的激活与安装（全网最靠谱，最快捷的方式）

前言&#xff1a; 相信很多小伙伴已经开始了java的学习之旅&#xff0c;想要更快乐的学习当然少不了IDEA这个得力的开发工具软件。但是IDEA是付费的&#xff0c;免费版功能有太少&#xff0c;怎么才能既免费&#xff0c;又能使用上正式版呢&#xff01;当然还是激活啦&#xf…
阅读更多...
数据结构与算法之美学习笔记：48 | B+树：MySQL数据库索引是如何实现的？

数据结构与算法之美学习笔记：48 | B+树：MySQL数据库索引是如何实现的？

目录 前言算法解析总结引申 前言 本节课程思维导图&#xff1a; 作为一个软件开发工程师&#xff0c;你对数据库肯定再熟悉不过了。作为主流的数据存储系统&#xff0c;它在我们的业务开发中&#xff0c;有着举足轻重的地位。在工作中&#xff0c;为了加速数据库中数据的查找速…
阅读更多...
maven导入无法拉取所需依赖

maven导入无法拉取所需依赖

maven导入无法拉取所需依赖 1.原因2.解决搞定收工&#xff01; 1.原因 公司使用的是gradle&#xff0c;配置的私有云&#xff0c;maven里面配置私有云完全使用不了&#xff0c;无论配置国内还是国外的&#xff0c;导入的项目报错拉不到jar包。 <mirror><id>mirro…
阅读更多...
【小智好书分享• 第一期】深度学习计算机视觉

【小智好书分享• 第一期】深度学习计算机视觉

目录 一、内容简介二、内页插图三、书籍目录四、粉丝福利 &#x1f389;博客主页&#xff1a;小智_x0___0x_ &#x1f389;欢迎关注&#xff1a;&#x1f44d;点赞&#x1f64c;收藏✍️留言 &#x1f389;系列专栏&#xff1a;好书分享 &#x1f389;代码仓库&#xff1a;小智…
阅读更多...
汇编代码生成和编译器的后端

汇编代码生成和编译器的后端

1.前置程序&#xff1a;语义分析和中间代码生成 基于SLR(1)分析的语义分析及中间代码生成程序-CSDN博客https://blog.csdn.net/lijj0304/article/details/135097554?spm1001.2014.3001.5501 2.程序目标 在前面编译器前端实现的基础上&#xff0c;将所生成的中间代码翻译成某…
阅读更多...
Windows11搭建Python环境（2）- Anaconda虚拟环境中安装Git

Windows11搭建Python环境（2）- Anaconda虚拟环境中安装Git

在搭建MetaGPT运行环境过程中&#xff0c;使用了Anaconda虚拟环境&#xff0c;在运行MetaGPT时出现错误&#xff1a; 可以看到是没有找到git指令。 在Windows上安装Git&#xff0c;可以直接去官网下载.exe文件&#xff0c;然后安装即可。 但是上面安装完成后&#xff0c;是无…
阅读更多...
三使用Docker Hub管理镜像

三使用Docker Hub管理镜像

使用Docker Hub管理镜像 Docker Hub是Docker官方维护的Docker Registry&#xff0c;上面存放着很多优秀的镜像。不仅如此&#xff0c;Docker Hub还提供认证、工作组结构、工作流工具、构建触发器等工具来简化我们的工作。 前文已经讲过&#xff0c;我们可使用docker search 命…
阅读更多...
【VUE】element-ui+vue-router:实现导航栏跳转路由

【VUE】element-ui+vue-router:实现导航栏跳转路由

实现目的 页面中点击导航栏菜单中的某一选项卡&#xff0c;使用导航栏进行路由跳转。如下图所示。 我们设计三个页面&#xff0c;首页是App.vue, 两个导航页面分别为 About.vue, Home.vue。在App.vue 页面中有导航菜单&#xff0c;点击菜单分别跳转。 1. 安装 npm install v…
阅读更多...
2024中国国际光伏展

2024中国国际光伏展

2024中国国际光伏展将是中国举办的一个重要的展览会&#xff0c;专门展示光伏技术和产业的最新发展。该展览会将吸引国内外光伏企业、研究机构、政府机构和专业人士参展和参观。 在2024年的中国国际光伏展上&#xff0c;参展商将展示他们最新的光伏技术、设备和产品&#xff0c…
阅读更多...
Jetson AGX Orin安装archiconda、Pytorch

Jetson AGX Orin安装archiconda、Pytorch

想在Jetson AGX Orin创建一个虚拟环境&#xff0c;然后安装pytorch&#xff0c;过程中遇到了很多的坑&#xff0c;这篇文章主要用于记录过程~因为Orin本身是Arm架构&#xff0c;X86架构可以装Anaconda&#xff0c;对于ARM要装archiconda。 1.安装archiconda 1.1确定操作系统架…
阅读更多...
[自动驾驶算法][从0开始轨迹预测]：二、自动驾驶系统中常用的坐标系及相应的转换关系

[自动驾驶算法][从0开始轨迹预测]：二、自动驾驶系统中常用的坐标系及相应的转换关系

自动驾驶中常见的坐标系与坐标转换 1. 传感器坐标系1.1 相机坐标系统1) 相机相关基础知识2) 相机各坐标系图像/像素坐标系相机坐标系像平面坐标系 3) 相机各坐标系之间的转换像平面坐标系到像素坐标系的转换&#xff08;平移缩放变换&#xff09;相机坐标系转像平面坐标系&…
阅读更多...
uniCloud ---- uni-captch实现图形验证码

uniCloud ---- uni-captch实现图形验证码

目录 用途说明 组成部分 目录结构 原理时序 云端一体组件介绍 验证码配置&#xff08;可选&#xff09;&#xff1a; 普通验证码组件 公共模块 云函数公用模块 项目实战 创建云函数 创建注册页 创建云函数 关联公用模块 uni-captcha 刷新验证码 自定义实现 验…
阅读更多...
【实战记录】 vagrant+virtualbox+docker 轻松用虚拟机集成组件

【实战记录】 vagrant+virtualbox+docker 轻松用虚拟机集成组件

用途 最近要学一大堆组件&#xff0c;不想直接安装本机上&#xff0c;然后gpt说&#xff1a;你可以用vagrant起个虚拟机&#xff08;然后docker拉取各种组件的镜像&#xff09;&#xff1b;或者k8s 实战的整体思路 首先安装virtualbox和vagrant。然后cmd依次键入三条命令 安…
阅读更多...
Linux批量快速修改文件名的三种方法

Linux批量快速修改文件名的三种方法

在Linux中&#xff0c;批量重命名文件是一项常见且有用的操作。以下是三种常用的批量重命名文件的方法&#xff0c;每种方法都附有示例。这些方法既可以适用于新手&#xff0c;也适用于更有经验的用户。 话不多说&#xff0c;直接上干货&#xff01; rename 命令 rename命令是…
阅读更多...
ITE IT6801FNBX HDMI接收器 芯片

ITE IT6801FNBX HDMI接收器 芯片

一、物料概述 IT6801FN是一款单端口HDMI接收器&#xff0c;可在HDMI1.4和MHL2.1双模式下工作&#xff0c;完全兼容MHL2.1、HDMI 1.4a、HDMI 1.4a3D和HDCP1.4&#xff0c;还可向后兼容DVI 1.0规格。IT6801FN具有深彩色功能&#xff08;高达36位&#xff09;&#xff0c;可确保接…
阅读更多...
Redis主从+哨兵集群(基于CentOS-8.0)高可用部署方案

Redis主从+哨兵集群(基于CentOS-8.0)高可用部署方案

目录 一、环境描述 二、Redis 主从集群部署 2.1 Redis下载 2.2 Redis解压 和移动文件 2.4 编译、安装Redis 2.6 新建 bin 和 etc 文件夹 2.7 分发Redis 2.8 配置 2.8.1 主节点配置 2.8.2 从节点配置 2.9 启动Redis服务 2.10 验证主从服务 2.11 查看节点角色信息 2…
阅读更多...
k8s的存储卷、数据卷---动态PV创建

k8s的存储卷、数据卷---动态PV创建

当发布PVC之后可以生成PV&#xff0c;还可以在动态服务器上直接生成挂载目录。PVC直接绑定和使用PV。 动态PV需要两个组件 存储卷插件&#xff1a;Provisioner(存储分配器)根据定义的属性创建PV StorageClass&#xff1a;定义属性 存储卷插件 存储卷插件&#xff1a;k8s本…
阅读更多...
从“AI证件照”到“AI译制片”，爆款AIGC应用的商业化迷思

从“AI证件照”到“AI译制片”，爆款AIGC应用的商业化迷思

文 | 脑极体 让郭德纲飙英文、让霉霉说中文的翻译视频生成工具HeyGen和掀起AI证件照热潮的“妙鸭相机”一样&#xff0c;在一阵疯狂刷屏之后&#xff0c;又迅速在各大群里销声匿迹了。 十月份&#xff0c;由HeyGen制作的各种明星跨语言翻译视频&#xff0c;在全网疯传&#xf…
阅读更多...
C#微信公众号HIS预约挂号系统源码

C#微信公众号HIS预约挂号系统源码

微信公众号预约挂号系统、支付宝小程序预约挂号系统主要是让自费、医保患者在手机上就能实现就医全过程&#xff0c;实时预约挂号、自费、医保结算&#xff0c;同时还可以查询检查检验报告等就诊信息&#xff0c;真正实现了让信息“多跑路”&#xff0c;让群众“少跑腿”。系统…
阅读更多...
最新文章

Copyright @ 2022~2023