feat: 观察者模式

README/设计模式.md

@@ -55,7 +55,8 @@ public class Singleton {
 
 #### 总结
 
-懒汉模式有时为了延迟初始化而牺牲了性能，特别是在多线程环境下。为了保证线程安全，可以采用双重检查锁定（DCL）或静态内部类的方式，而**静态内部类方式是最推荐的方式**，它避免了同步开销，同时也能确保线程安全。
+懒汉模式有时为了延迟初始化而牺牲了性能，特别是在多线程环境下。为了保证线程安全，可以采用双重检查锁定（DCL）或静态内部类的方式，而**静态内部类方式是最推荐的方式**
+，它避免了同步开销，同时也能确保线程安全。
 
 - **优点**：
     1. 延迟加载，节省资源。
@@ -69,7 +70,8 @@ public class Singleton {
 
 ### 饿汉模式
 
-**饿汉模式**（Eager Initialization）是单例模式的一种实现方式，在该方式中，单例实例在类加载时就已经创建完成，而不是在首次使用时才创建。换句话说，**饿汉模式**的单例实例在类被加载时就会立即初始化，确保了单例模式的唯一性。
+**饿汉模式**（Eager Initialization）是单例模式的一种实现方式，在该方式中，单例实例在类加载时就已经创建完成，而不是在首次使用时才创建。换句话说，**饿汉模式**
+的单例实例在类被加载时就会立即初始化，确保了单例模式的唯一性。
 
 ```java
 public class Singleton {
@@ -103,7 +105,8 @@ public class Singleton {
 
 ### 枚举类型实现
 
-**枚举类型实现单例模式**（Enum Singleton）是实现单例模式的另一种方式，优点是更加简洁、可靠，并且避免了许多常见的单例实现方式（如懒汉模式和饿汉模式）可能出现的问题。使用枚举类型的单例实现方式自 **Java 5** 引入以来，已经成为了最推荐的单例模式实现方式之一。
+**枚举类型实现单例模式**（Enum Singleton）是实现单例模式的另一种方式，优点是更加简洁、可靠，并且避免了许多常见的单例实现方式（如懒汉模式和饿汉模式）可能出现的问题。使用枚举类型的单例实现方式自
+**Java 5** 引入以来，已经成为了最推荐的单例模式实现方式之一。
 
 **当你不需要懒加载或延迟初始化时，使用枚举实现单例模式是最理想的选择。**
 
@@ -312,6 +315,7 @@ class ConcreteProductB2 implements ProductB {
 
 interface AbstractFactory {
     ProductA createProductA();
+
     ProductB createProductB();
 }
 
@@ -361,3 +365,373 @@ 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();
+    }
+}