🍉 observer pattern

Author: fengyuan-liang

web/.DS_Store

@@ -3243,8 +3243,171 @@ Comparator<Integer> comparator= (o1, o2) -> {
 >
 >观察者模式又被称为`发布-订阅（Publish/Subscribe）`，当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知依赖它的对象。观察者模式属于行为型模式。
 >
+
+访问者模式
+
+```java
+package com.fx.behaviorPattern.observer.d;
+
+
+import lombok.Data;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Test {
+    public static void main(String[] args) {
+        Role role = new Role();
+        role.setName("角色");
+        role.setHp(100);
+
+        Panel panel = new Panel(role);
+        role.addObserver(panel);
+
+        BallPanel ballPanel = new BallPanel(role);
+        role.addObserver(ballPanel);
+
+        HeadPanel headPanel = new HeadPanel(role);
+        role.addObserver(headPanel);
+
+        Monster monster = new Monster();
+        monster.attack(role);
+        monster.attack(role);
+        monster.attack(role);
+    }
+}
+
+@Data
+class Role {
+    private String name;
+    /**
+     * 血量
+     **/
+    private int hp;
+    /**
+     * 魔法值（蓝）
+     **/
+    private int mp;
+    /**
+     * 所有观察者
+     **/
+    private List<Observer> observers = new ArrayList<>();
+
+    public void addObserver(Observer obj) {
+        observers.add(obj);
+    }
+
+    public void removeObserver(Observer obj) {
+        observers.remove(obj);
+    }
+
+    public void notifyObservers() {
+        observers.forEach(Observer::notifyObserver);
+    }
+
+    public void setHp(int hp) {
+        // 更新血条的时候，一定要通知三个地方：1. 血条、球、面板
+        this.hp = hp;
+        System.out.println("血条更新为：" + hp);
+
+        System.out.println("球形更新为：" + hp);
+        System.out.println("面板更新为：" + hp);
+    }
+
+    @Override
+    public String toString() {
+        return "Role{" +
+                "name='" + name + '\'' +
+                ", hp=" + hp +
+                ", mp=" + mp +
+                '}';
+    }
+}
+
+class Monster {
+    public void attack(Role r) {
+        r.setHp(r.getHp() - 10);
+        r.notifyObservers();
+    }
+}
+
+/**
+ * 观察者们需要一个方法来接收数据
+ */
+
+interface Observer {
+    void notifyObserver();
+}
+
+/**
+ * 观察者模式拥有很多变体
+ */
+class Panel implements Observer {
+    /**
+     * 访问者模式其中一种实现就是要持有数据的引用 也就是推拉的形式
+     * 推，让数据源推消息给观察者
+     * 拉，观察者拉取自己关心的数据
+     */
+    private final Role r;
+
+    public Panel(Role r) {
+        this.r = r;
+    }
+
+    @Override
+    public void notifyObserver() {
+        System.out.printf("Panel 更新血条了值为：%d\n", r.getHp());
+    }
+}
+
+class BallPanel implements Observer {
+    private final Role r;
+
+    public BallPanel(Role r) {
+        this.r = r;
+    }
+
+    @Override
+    public void notifyObserver() {
+        System.out.printf("Panel 更新血条了值为：%d\n", r.getHp());
+    }
+}
+
+class HeadPanel implements Observer {
+    private final Role r;
+
+    public HeadPanel(Role r) {
+        this.r = r;
+    }
+
+    @Override
+    public void notifyObserver() {
+        System.out.printf("Panel 更新血条了值为：%d\n", r.getHp());
+    }
+}
+
+```
+
+#### 4.2.3 观察者模式总结
+
+![image-20231105234455568](https://cdn.fengxianhub.top/resources-master/image-20231105234455568.png)
+
+
+
+### 4.3 访问者模式
+
+>**访问者（Visitor）模式**：封装一些作用于某种数据结构中的各元素的操作，它可以在不改变这个数据结构的前提下定义作用于这些元素的新的操作
+>
 >🧨观察者模式的本质是想实现`多重派发 (multiple dispatch)`，由于Java中只有函数参数重载实现的单派发(single dispatch)，所以需要这个模式去模拟，如果用支持多派发的语言如clojue或者common lisp、js，就不需要观察者模式了，在golang中也可以通过接口和类型断言来模拟实现多派发。
 
+![img](https://cdn.fengxianhub.top/resources-master/e4a5535e-29c6-3aa2-8b0c-3f51cc49d980.png)
+
+**抽象访问者（Visitor）角色**：定义接口，声明一个或多个访问操作。 
+**具体访问者（ConcreteVisitor）角色**：实现抽象访问者所声明的接口，也就是抽象访问者所声明的各个访问操作。 
+**抽象元素（Visitable）角色**：声明一个接受操作，接受一个访问者对象作为一个参数。 
+**具体元素结点（ConcreteElement）角色**：实现抽象结点所规定的接受操作。 
+**数据结构对象（ObjectStructure）角色**：可以遍历结构中的所有元素，提供一个接口让访问者对象都可以访问每一个元素。
+
 下面用一个经典的墨子骑马🏇的故事来描述java遇到的多派发的问题
 
 ```java
@@ -3325,7 +3488,7 @@ class BlackHorse implements Horse {}
 
 如果解决呢？一般有两种做法
 
-#### 4.2.1 类型判断解决多派分发问题
+#### 4.3.1 类型判断解决多派分发问题
 
 在方法里使用`instanceof`判断真实类型，比如（java.awt.Component的源码）
 
@@ -3394,7 +3557,7 @@ protected void processEvent(AWTEvent e) {
 
 这种方法实现的双重分派都格外的冗长、复杂和容易出错，也不符合`开闭原则`
 
-#### 4.2.2 反转球实现动态分发
+#### 4.3.2 反转球实现动态分发
 
 通过两次的调用来实现，比如下面剪刀石头布的游戏：
 
@@ -3509,7 +3672,7 @@ RoshamBol.match()有2个item参数，通关过Item.compete()方法开始2路分
 
 这种实现也就是“访问者模式”的精华。
 
-#### 4.2.4 golang实现多派发
+#### 4.3.4 golang实现多派发
 
 ```go
 package main
@@ -3553,7 +3716,7 @@ func main() {
 }
 ```
 
-#### 4.2.5 js实现多派发
+#### 4.3.5 js实现多派发
 
 ```javascript
 class Shape {
@@ -3597,7 +3760,7 @@ calculateArea(circle);    // 输出：Area: 78.54
 calculateArea(rectangle); // 输出：Area: 12.00
 ```
 
-#### 4.2.6 java需要借助观察者模式或者访问者模式实现
+#### 4.3.6 java需要借助观察者模式或者访问者模式实现
 
 ```java
 interface Shape {
@@ -3671,9 +3834,11 @@ public class Main {
 }
 ```
 
+### 
+
 
 
-### 4.3 状态机模式
+### 4.4 状态机模式
 
 >**状态机模式**
 >
@@ -3691,7 +3856,7 @@ public class Main {
 
 打个比方，当订单的状态由待支付变成已支付时，我们需要它能够自动完成例如订单持久化等操作
 
-#### 4.3.1 问题引入
+#### 4.4.1 问题引入
 
 在没有状态机模式之前，我们大概率是直接搞个字段`status`放到表里面，然后在业务代码里面去修改里面的状态，然后在需要用到状态的地方再去查一下db，我们想想这样有哪些弊端？
 
@@ -3726,7 +3891,7 @@ public class Main {
 
 
 
-#### 4.3.2 状态模式解决问题
+#### 4.4.3 状态模式解决问题
 
 
 
@@ -3742,7 +3907,7 @@ public class Main {
 
 
 
-#### 4.3.3 市面上的状态机
+#### 4.4.3 市面上的状态机
 
 目前开源的状态机实现方案有：
 
@@ -3781,13 +3946,13 @@ public class Main {
 
 
 
-#### 4.3.4 spring状态机
+#### 4.4.4 spring状态机
 
 https://www.cnblogs.com/Zero-Jo/p/13891075.html
 
 
 
-#### 4.3.5阿里状态机-cola stateMachine
+#### 4.4.5阿里状态机-cola stateMachine
 
 https://www.cnblogs.com/Zero-Jo/p/14622937.html