feat: 观察者模式

README/设计模式.md

@@ -55,21 +55,23 @@ public class Singleton {
 
 #### 总结
 
-懒汉模式有时为了延迟初始化而牺牲了性能，特别是在多线程环境下。为了保证线程安全，可以采用双重检查锁定（DCL）或静态内部类的方式，而**静态内部类方式是最推荐的方式**，它避免了同步开销，同时也能确保线程安全。
+懒汉模式有时为了延迟初始化而牺牲了性能，特别是在多线程环境下。为了保证线程安全，可以采用双重检查锁定（DCL）或静态内部类的方式，而**静态内部类方式是最推荐的方式**
+，它避免了同步开销，同时也能确保线程安全。
 
 - **优点**：
-  1. 延迟加载，节省资源。
+    1. 延迟加载，节省资源。
-  2. 内存优化，只有在需要时才实例化。
+    2. 内存优化，只有在需要时才实例化。
-  3. 减少不必要的初始化开销。
+    3. 减少不必要的初始化开销。
 - **缺点**：
-  1. 传统懒汉模式线程不安全（多个线程可能会创建多个实例）。
+    1. 传统懒汉模式线程不安全（多个线程可能会创建多个实例）。
-  2. 使用同步机制会有性能开销，特别是在多线程环境下。
+    2. 使用同步机制会有性能开销，特别是在多线程环境下。
-  3. 代码复杂性较高，容易引入错误。
+    3. 代码复杂性较高，容易引入错误。
-  4. 不适合高并发场景，特别是频繁访问时会影响性能。
+    4. 不适合高并发场景，特别是频繁访问时会影响性能。
 
 ### 饿汉模式
 
-**饿汉模式**（Eager Initialization）是单例模式的一种实现方式，在该方式中，单例实例在类加载时就已经创建完成，而不是在首次使用时才创建。换句话说，**饿汉模式**的单例实例在类被加载时就会立即初始化，确保了单例模式的唯一性。
+**饿汉模式**（Eager Initialization）是单例模式的一种实现方式，在该方式中，单例实例在类加载时就已经创建完成，而不是在首次使用时才创建。换句话说，**饿汉模式**
+的单例实例在类被加载时就会立即初始化，确保了单例模式的唯一性。
 
 ```java
 public class Singleton {
@@ -103,7 +105,8 @@ public class Singleton {
 
 ### 枚举类型实现
 
-**枚举类型实现单例模式**（Enum Singleton）是实现单例模式的另一种方式，优点是更加简洁、可靠，并且避免了许多常见的单例实现方式（如懒汉模式和饿汉模式）可能出现的问题。使用枚举类型的单例实现方式自 **Java 5** 引入以来，已经成为了最推荐的单例模式实现方式之一。
+**枚举类型实现单例模式**（Enum Singleton）是实现单例模式的另一种方式，优点是更加简洁、可靠，并且避免了许多常见的单例实现方式（如懒汉模式和饿汉模式）可能出现的问题。使用枚举类型的单例实现方式自
+**Java 5** 引入以来，已经成为了最推荐的单例模式实现方式之一。
 
 **当你不需要懒加载或延迟初始化时，使用枚举实现单例模式是最理想的选择。**
 
@@ -147,11 +150,11 @@ public class Main {
 简单工厂模式是工厂模式的一种简单形式，**它并不属于设计模式中的结构**，它是通过一个工厂类来决定创建哪一个产品类的实例。
 
 - 特点
-  - 由工厂类来决定实例化哪个产品类，不暴露具体的产品创建过程。
+    - 由工厂类来决定实例化哪个产品类，不暴露具体的产品创建过程。
-  - 客户端不需要知道产品类的具体信息，减少了与产品类的耦合。
+    - 客户端不需要知道产品类的具体信息，减少了与产品类的耦合。
 - 优缺点
-  - 优点：客户端不需要关心对象的创建细节，降低了代码的耦合度。
+    - 优点：客户端不需要关心对象的创建细节，降低了代码的耦合度。
-  - 缺点：工厂类需要维护一个 `if` 或 `switch` 来判断创建哪种产品，如果产品种类增加，工厂类会变得非常庞大且难以维护。
+    - 缺点：工厂类需要维护一个 `if` 或 `switch` 来判断创建哪种产品，如果产品种类增加，工厂类会变得非常庞大且难以维护。
 
 **示例**：
 
@@ -202,11 +205,11 @@ public class Client {
 工厂方法模式是工厂模式的核心。它通过定义一个接口来创建对象，由子类来决定实例化哪一个类。工厂方法模式将简单工厂中的创建产品的逻辑分散到了各个具体的工厂类中。
 
 - 特点
-  - 定义一个创建对象的接口，但让子类来决定具体实例化哪一个产品。
+    - 定义一个创建对象的接口，但让子类来决定具体实例化哪一个产品。
-  - 通过继承和多态来解决简单工厂的缺点，避免了在一个类中维护大量的 `if` 或 `switch` 语句。
+    - 通过继承和多态来解决简单工厂的缺点，避免了在一个类中维护大量的 `if` 或 `switch` 语句。
 - 优缺点
-  - 优点：符合开闭原则，增加新产品时只需要添加新的工厂类，不需要修改现有代码。
+    - 优点：符合开闭原则，增加新产品时只需要添加新的工厂类，不需要修改现有代码。
-  - 缺点：增加了类的数量，系统更为复杂。
+    - 缺点：增加了类的数量，系统更为复杂。
 
 **示例**：
 
@@ -252,7 +255,7 @@ public class Client {
         Creator creatorA = new ConcreteCreatorA();
         Product productA = creatorA.factoryMethod();
         productA.use();
-        
+
         Creator creatorB = new ConcreteCreatorB();
         Product productB = creatorB.factoryMethod();
         productB.use();
@@ -265,11 +268,11 @@ public class Client {
 抽象工厂模式是工厂模式的进一步扩展，它提供了一个接口，用于创建一组相关或相互依赖的对象，而无需指定具体的类。与工厂方法模式不同，抽象工厂模式更侧重于一组产品的创建，而不是单个产品的创建。
 
 - 特点
-  - 提供一个接口，用来创建相关或依赖的多个产品。
+    - 提供一个接口，用来创建相关或依赖的多个产品。
-  - 客户端通过抽象工厂来获取一系列的产品对象，而无需知道具体的实现。
+    - 客户端通过抽象工厂来获取一系列的产品对象，而无需知道具体的实现。
 - 优缺点
-  - 优点：可以方便地更换产品系列（产品的族），符合开闭原则。
+    - 优点：可以方便地更换产品系列（产品的族），符合开闭原则。
-  - 缺点：增加了系统的复杂性，如果新增产品族或产品种类时需要修改现有的代码。
+    - 缺点：增加了系统的复杂性，如果新增产品族或产品种类时需要修改现有的代码。
 
 **示例**：
 
@@ -312,6 +315,7 @@ class ConcreteProductB2 implements ProductB {
 
 interface AbstractFactory {
     ProductA createProductA();
+
     ProductB createProductB();
 }
 
@@ -346,7 +350,7 @@ public class Client {
         ProductB productB1 = factory1.createProductB();
         productA1.useA();
         productB1.useB();
-        
+
         AbstractFactory factory2 = new ConcreteFactory2();
         ProductA productA2 = factory2.createProductA();
         ProductB productB2 = factory2.createProductB();
@@ -360,4 +364,374 @@ public class Client {
 
 - **简单工厂模式**：由工厂类根据不同的条件决定创建不同的对象，适合产品种类少且变化不大时。
 - **工厂方法模式**：通过子类来决定产品的创建，适合产品种类较多时，且产品可能会变化。
-- **抽象工厂模式**：提供多个相关的产品的创建接口，适合需要创建一系列相关产品的场景。
+- **抽象工厂模式**：提供多个相关的产品的创建接口，适合需要创建一系列相关产品的场景。
+
+## 策略模式
+
+![image-20250131223259043](./images/设计模式/image-20250131223259043.png)
+
+![image-20250131223315954](./images/设计模式/image-20250131223315954.png)
+
+我们通过策略模式来实现鸭子的飞行和叫声行为，使得它们可以在运行时灵活替换。
+
+### 飞行行为
+
+#### 飞行接口
+
+```java
+public interface FlyBehavior {
+    /**
+     * 飞的样子
+     */
+    void fly();
+}
+```
+
+#### 飞行实现
+
+```java
+public class FlyNoWay implements FlyBehavior {
+    /**
+     * 飞的样子
+     */
+    @Override
+    public void fly() {
+        System.out.println("不能飞。。。");
+    }
+}
+
+public class FlyWithWings implements FlyBehavior {
+    /**
+     * 飞的样子
+     */
+    @Override
+    public void fly() {
+        System.out.println("可以飞。。。");
+    }
+}
+
+```
+
+### 叫的行为
+
+#### 叫的接口
+
+```java
+public interface QuackBehavior {
+    /**
+     * 怎么叫的
+     */
+    void quack();
+}
+```
+
+#### 叫的实现
+
+```java
+public class MuteQuack implements QuackBehavior {
+    /**
+     * 怎么叫的
+     */
+    @Override
+    public void quack() {
+        System.out.println("不会叫...");
+    }
+}
+
+public class Quack implements QuackBehavior {
+    /**
+     * 怎么叫的
+     */
+    @Override
+    public void quack() {
+        System.out.println("鸭子叫。。。");
+    }
+}
+```
+
+### 鸭子
+
+```java
+@Setter
+public abstract class AbstractDuck {
+    // 设置新的叫声行为
+    QuackBehavior quackBehavior;
+    // 设置新的飞行行为
+    FlyBehavior flyBehavior;
+
+    public AbstractDuck() {
+    }
+
+    /**
+     * 展示什么类型的鸭子
+     */
+    public abstract void display();
+
+    public void performFly() {
+        flyBehavior.fly();
+    }
+
+    public void performQuack() {
+        quackBehavior.quack();
+    }
+
+    public void swim() {
+        System.out.println("鸭子游泳");
+    }
+}
+```
+
+#### 鸭子继承
+
+```java
+public class ModelDuck extends AbstractDuck {
+
+    private final String modelDuck = "橡皮🦆";
+
+    public ModelDuck() {
+        super.setFlyBehavior(new FlyNoWay());
+        super.quackBehavior = new MuteQuack();
+    }
+
+    /**
+     * 展示什么类型的鸭子
+     */
+    @Override
+    public void display() {
+        System.out.println(modelDuck + "...");
+    }
+
+    /**
+     *
+     */
+    @Override
+    public void swim() {
+        System.out.println(modelDuck + "不会游泳。。。");
+    }
+}
+
+public class WoodDuck extends AbstractDuck {
+
+    private final String modelDuck = "木头🦆";
+
+    public WoodDuck() {
+        super.flyBehavior = new FlyNoWay();
+        super.quackBehavior = new MuteQuack();
+    }
+
+    /**
+     * 展示什么类型的鸭子
+     */
+    @Override
+    public void display() {
+        System.out.println(modelDuck + "...");
+    }
+}
+```
+
+### 运行 
+
+```java
+public class Main {
+    public static void main(String[] args) {
+        ModelDuck modelDuck = new ModelDuck();
+        modelDuck.display();
+        modelDuck.performFly();
+        modelDuck.performQuack();
+        modelDuck.swim();
+
+        System.out.println("--------------------------------");
+
+        AbstractDuck woodDuck = new WoodDuck();
+        woodDuck.display();
+        woodDuck.performFly();
+        woodDuck.performQuack();
+        woodDuck.swim();
+    }
+}
+```
+
+![image-20250131224206984](./images/设计模式/image-20250131224206984.png)
+
+## 观察者模式
+
+观察者模式是一种行为设计模式，它允许一个对象（被观察者）在其状态发生变化时，自动通知所有依赖于它的对象（观察者），而不需要知道这些观察者的具体细节。其主要思想是实现“低耦合”，即对象之间的关系通过接口进行松散连接。
+
+![image-20250131222844877](./images/设计模式/image-20250131222844877.png)
+
+![image-20250131222858501](./images/设计模式/image-20250131222858501.png)
+
+为了避免使用过时的类，我们可以手动实现观察者模式。我们需要定义一个“观察者”接口和一个“被观察者”接口，并在被观察者中维护一个观察者的列表，通知观察者更新状态。
+
+### 观察者
+
+#### 观察者接口
+
+```java
+/**
+ * 观察者接口
+ */
+public interface Observer {
+
+    /**
+     * 更新数据
+     *
+     * @param temperature 温度
+     * @param humidity    湿度
+     * @param pressure    气压
+     */
+    void update(float temperature, float humidity, float pressure);
+}
+```
+
+#### 观察者的实现
+
+```java
+public class Observer1 implements Observer {
+
+    /**
+     * 更新数据
+     *
+     * @param temperature 温度
+     * @param humidity    湿度
+     * @param pressure    气压
+     */
+    @Override
+    public void update(float temperature, float humidity, float pressure) {
+        System.out.println("Observer1 显示数据：temperature = " + temperature + ";humidity = " + humidity);
+    }
+}
+
+public class Observer2 implements Observer {
+
+    /**
+     * 更新数据
+     *
+     * @param temperature 温度
+     * @param humidity    湿度
+     * @param pressure    气压
+     */
+    @Override
+    public void update(float temperature, float humidity, float pressure) {
+        System.out.println("Observer2 显示数据：temperature = " + temperature + ";humidity = " + humidity);
+
+    }
+}
+
+public class Observer3 implements Observer {
+
+    /**
+     * 更新数据
+     *
+     * @param temperature 温度
+     * @param humidity    湿度
+     * @param pressure    气压
+     */
+    @Override
+    public void update(float temperature, float humidity, float pressure) {
+        System.out.println("Observer3 显示数据：temperature = " + temperature + ";humidity = " + humidity);
+    }
+}
+```
+
+### 主题
+
+#### 主体接口
+
+```java
+/**
+ * 被观察者接口
+ */
+public interface Subject {
+    void registerObserver(Observer observer);
+
+    void removeObserver(Observer observer);
+
+    void notifyObservers();
+}
+```
+
+#### 主体实现
+
+```java
+import cn.bunny.pattern3.observer.Observer;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 被观察者类
+ */
+public class WeatherStationSubject implements Subject {
+    private final List<Observer> observers = new ArrayList<>();
+    private float temperature;
+    private float humidity;
+    private float pressure;
+
+    @Override
+    public void registerObserver(Observer observer) {
+        observers.add(observer);
+    }
+
+    @Override
+    public void removeObserver(Observer observer) {
+        observers.remove(observer);
+    }
+
+    @Override
+    public void notifyObservers() {
+        for (Observer observer : observers) {
+            observer.update(temperature, humidity, pressure);
+        }
+    }
+
+    public void setTemperature(float temperature, float humidity, float pressure) {
+        this.temperature = temperature;
+        this.humidity = humidity;
+        this.pressure = pressure;
+        notifyObservers();
+    }
+}
+```
+
+### 运行
+
+```java
+import cn.bunny.pattern3.observer.Observer;
+import cn.bunny.pattern3.observer.Observer1;
+import cn.bunny.pattern3.observer.Observer2;
+import cn.bunny.pattern3.observer.Observer3;
+import cn.bunny.pattern3.subject.WeatherStationSubject;
+
+public class Main {
+    public static void main(String[] args) {
+        WeatherStationSubject weatherStationSubject = new WeatherStationSubject();
+        Observer observer1 = new Observer1();
+        Observer observer2 = new Observer2();
+        Observer observer3 = new Observer3();
+
+        // 注册观察者
+        weatherStationSubject.registerObserver(observer1);
+        weatherStationSubject.registerObserver(observer2);
+        weatherStationSubject.registerObserver(observer3);
+
+        // 更新天气温度，观察者会收到通知
+        weatherStationSubject.setTemperature(25.0f, 25.0f, 25.0f);
+        weatherStationSubject.setTemperature(30.0f, 30.0f, 30.0f);
+
+        // 移出观察者1
+        weatherStationSubject.removeObserver(observer1);
+
+        // 更新天气温度，观察者会收到通知
+        System.out.println("--------------------------");
+        weatherStationSubject.setTemperature(44.0f, 44.0f, 44.0f);
+    }
+}
+```
+
+![image-20250131223737965](./images/设计模式/image-20250131223737965.png)
+
+## 装饰者模式
+
+
+

pattern/src/main/java/cn/bunny/pattern2/Main.java

@@ -12,6 +12,8 @@ public class Main {
         modelDuck.performQuack();
         modelDuck.swim();
 
+        System.out.println("--------------------------------");
+
         AbstractDuck woodDuck = new WoodDuck();
         woodDuck.display();
         woodDuck.performFly();

pattern/src/main/java/cn/bunny/pattern2/duck/AbstractDuck.java

@@ -30,5 +30,4 @@ public abstract class AbstractDuck {
     public void swim() {
         System.out.println("鸭子游泳");
     }
-
 }

pattern/src/main/java/cn/bunny/pattern3/Main.java

@@ -0,0 +1,33 @@
+package cn.bunny.pattern3;
+
+
+import cn.bunny.pattern3.observer.Observer;
+import cn.bunny.pattern3.observer.Observer1;
+import cn.bunny.pattern3.observer.Observer2;
+import cn.bunny.pattern3.observer.Observer3;
+import cn.bunny.pattern3.subject.WeatherStationSubject;
+
+public class Main {
+    public static void main(String[] args) {
+        WeatherStationSubject weatherStationSubject = new WeatherStationSubject();
+        Observer observer1 = new Observer1();
+        Observer observer2 = new Observer2();
+        Observer observer3 = new Observer3();
+
+        // 注册观察者
+        weatherStationSubject.registerObserver(observer1);
+        weatherStationSubject.registerObserver(observer2);
+        weatherStationSubject.registerObserver(observer3);
+
+        // 更新天气温度，观察者会收到通知
+        weatherStationSubject.setTemperature(25.0f, 25.0f, 25.0f);
+        weatherStationSubject.setTemperature(30.0f, 30.0f, 30.0f);
+
+        // 移出观察者1
+        weatherStationSubject.removeObserver(observer1);
+
+        // 更新天气温度，观察者会收到通知
+        System.out.println("--------------------------");
+        weatherStationSubject.setTemperature(44.0f, 44.0f, 44.0f);
+    }
+}

pattern/src/main/java/cn/bunny/pattern3/observer/Observer.java

@@ -0,0 +1,16 @@
+package cn.bunny.pattern3.observer;
+
+/**
+ * 观察者接口
+ */
+public interface Observer {
+
+    /**
+     * 更新数据
+     *
+     * @param temperature 温度
+     * @param humidity    湿度
+     * @param pressure    气压
+     */
+    void update(float temperature, float humidity, float pressure);
+}

pattern/src/main/java/cn/bunny/pattern3/observer/Observer1.java

@@ -0,0 +1,17 @@
+package cn.bunny.pattern3.observer;
+
+public class Observer1 implements Observer {
+
+    /**
+     * 更新数据
+     *
+     * @param temperature 温度
+     * @param humidity    湿度
+     * @param pressure    气压
+     */
+    @Override
+    public void update(float temperature, float humidity, float pressure) {
+        System.out.println("Observer1 显示数据：temperature = " + temperature + ";humidity = " + humidity);
+    }
+}
+

pattern/src/main/java/cn/bunny/pattern3/observer/Observer2.java

@@ -0,0 +1,17 @@
+package cn.bunny.pattern3.observer;
+
+public class Observer2 implements Observer {
+
+    /**
+     * 更新数据
+     *
+     * @param temperature 温度
+     * @param humidity    湿度
+     * @param pressure    气压
+     */
+    @Override
+    public void update(float temperature, float humidity, float pressure) {
+        System.out.println("Observer2 显示数据：temperature = " + temperature + ";humidity = " + humidity);
+
+    }
+}

pattern/src/main/java/cn/bunny/pattern3/observer/Observer3.java

@@ -0,0 +1,16 @@
+package cn.bunny.pattern3.observer;
+
+public class Observer3 implements Observer {
+
+    /**
+     * 更新数据
+     *
+     * @param temperature 温度
+     * @param humidity    湿度
+     * @param pressure    气压
+     */
+    @Override
+    public void update(float temperature, float humidity, float pressure) {
+        System.out.println("Observer3 显示数据：temperature = " + temperature + ";humidity = " + humidity);
+    }
+}

pattern/src/main/java/cn/bunny/pattern3/subject/Subject.java

@@ -0,0 +1,14 @@
+package cn.bunny.pattern3.subject;
+
+import cn.bunny.pattern3.observer.Observer;
+
+/**
+ * 被观察者接口
+ */
+public interface Subject {
+    void registerObserver(Observer observer);
+
+    void removeObserver(Observer observer);
+
+    void notifyObservers();
+}

pattern/src/main/java/cn/bunny/pattern3/subject/WeatherStationSubject.java

@@ -0,0 +1,41 @@
+package cn.bunny.pattern3.subject;
+
+
+import cn.bunny.pattern3.observer.Observer;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 被观察者类
+ */
+public class WeatherStationSubject implements Subject {
+    private final List<Observer> observers = new ArrayList<>();
+    private float temperature;
+    private float humidity;
+    private float pressure;
+
+    @Override
+    public void registerObserver(Observer observer) {
+        observers.add(observer);
+    }
+
+    @Override
+    public void removeObserver(Observer observer) {
+        observers.remove(observer);
+    }
+
+    @Override
+    public void notifyObservers() {
+        for (Observer observer : observers) {
+            observer.update(temperature, humidity, pressure);
+        }
+    }
+
+    public void setTemperature(float temperature, float humidity, float pressure) {
+        this.temperature = temperature;
+        this.humidity = humidity;
+        this.pressure = pressure;
+        notifyObservers();
+    }
+}