笨蛋学设计模式行为型模式-观察者模式【14】

8.1观察者模式??????

8.1.1概念

? 观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，当主题对象状态发生变化时，会通知所有依赖它的观察者对象，使它们都能够得到通知并且被自动更新

8.1.2场景

? 在我们生活中，用户可以在音乐播放平台关注多个歌手，而当有歌手发布新的歌曲时，可以将歌曲发布到音乐播放平台，而平台会将新的歌曲详细信息发送给关注该歌手的用户。而此时歌手就相当于是观察者模式的主题对象，每个关注的用户则是观察者模式中的观察者对象，通过该模式，用户可以很及时的听到歌手的新歌曲，而歌手也可以很轻松的通知用户新歌曲的发布。

8.1.3优势 / 劣势

• 灵活性：提供了灵活的观察者注册机制，可以随时添加或删除观察者，使得系统更加灵活和可扩展
• 自动更新：当被观察者的状态发生改变时，所有依赖它的观察者都会自动收到通知并更新，提高了系统的自动化程度

---

• 性能影响：当被观察者的状态发生改变时，所有观察者都会收到通知并且进行相应的通知，可能导致大量的通知和计算，影响系统性能
• 通知竞态条件：若多个线程同时修改被观察者的状态，可能会产生竞态条件，导致某些观察者未能及时收到通知或收到错误的通知

8.1.4观察者模式可分为

• 主题Subject：就是被观察的对象，可以维护一组观察者，当主题本身发生改变时就会通知观察者
• 观察者Observer：观察主题的对象，当"被观察"的主题发生变化时，观察者就会得到通知并执行相应的处理

---

观察者的基本结构：

• 主题Subject：一般会定义成一个接口，提供方法用于注册、删除、通知观察者，通常也包含一个状态，当状态发生改变时，通知所有的观察者
• 观察者Observer：观察者也需要实现一个接口，包含一个更新方法，在接收主题通知时执行对应的操作
• 具体主题ConcreteSubject：主题的具体实现，维护一个观察者列表，包含了观察者的注册、删除、通知方法
• 具体观察者ConcreteObserver：观察者接口的具体实现，每个具体

8.1.5观察者模式

package com.technologystatck.designpattern.mode.observer;

import java.util.ArrayList;
import java.util.List;

public class Observers {
    public static void main(String[] args) {

        //创建具体主题对象
        ConcreteSubject concreteSubject = new ConcreteSubject();

        //创建具体观察者对象
        Observer concreteObserverA = new ConcreteObserver();
        Observer concreteObserverB = new ConcreteObserver();

        //注册观察者
        concreteSubject.registerObserver(concreteObserverA);
        concreteSubject.registerObserver(concreteObserverB);

        //调用主题方法
        concreteSubject.setState("有新的观察者注册");
    }
}

//主题接口(主题)
interface Subject{
    //注册观察者
    void registerObserver(Observer observer);

    //移除观察者
    void removeObserver(Observer observer);

    //通知观察者
    void notifyObserver();
}

//观察者接口(观察者)
interface Observer{
    //更新方法
    void update(String message);
}

//具体主题实现
class ConcreteSubject implements Subject{

    //观察者列表
    private List<Observer> observers = new ArrayList<>();

    //状态
    private String state;

    //注册观察者方法(注册)
    @Override
    public void registerObserver(Observer observer) {
        observers.add(observer);
    }

    //移除观察者方法(移除)
    @Override
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    //通知观察者方法(通知)
    //遍历观察者列表，并通知每个观察者更新状态
    @Override
    public void notifyObserver() {
        for (Observer observer : observers) {
            observer.update(state);
        }
    }

    //更新状态
    public void setState(String state) {
        this.state = state;
        notifyObserver();
    }
}
//具体观察者实现
class ConcreteObserver implements Observer{
    //更新方法
    @Override
    public void update(String message) {
        System.out.println(message);
    }
}

8.1.6实战

8.1.1.1题目描述

小明所在的学校有一个时钟（主题），每到整点时，它就会通知所有的学生（观察者）当前的时间，请你使用观察者模式实现这个时钟通知系统。

注意点：时间从 0 开始，并每隔一个小时更新一次。

8.1.6.2输入描述

输入的第一行是一个整数 N（1 ≤ N ≤ 20），表示学生的数量。

接下来的 N 行，每行包含一个字符串，表示学生的姓名。

最后一行是一个整数，表示时钟更新的次数。

8.1.6.3输出描述

对于每一次时钟更新，输出每个学生的姓名和当前的时间。

8.1.6.4代码

package com.technologystatck.designpattern.mode.observer;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // 读取学?数量
        int N = scanner.nextInt();
        // 创建时钟
        Clock clock = new Clock();
        // 注册学?观察者
        for (int i = 0; i < N; i++) {
            String studentName = scanner.next();
            clock.registerObserver(new Student(studentName));
        }
        // 读取时钟更新次数
        int updates = scanner.nextInt();
        // 模拟时钟每隔?个?时更新?次
        for (int i = 0; i < updates; i++) {
            clock.tick();
        }
    }
}

// 观察者接?
interface Observer {
    void update(int hour);
}
// 主题接?
interface Subject {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}
// 具体主题实现
class Clock implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private int hour = 0;
    @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(hour);
        }
    }
    public void tick() {
        hour = (hour + 1) % 24; // 模拟时间的推移
        notifyObservers();
    }
}
// 具体观察者实现
class Student implements Observer {
    private String name;
    public Student(String name) {
        this.name = name;
    }
    @Override
    public void update(int hour) {
        System.out.println(name + " " + hour);
    }
}

8.1.7总结

• 优点：可以灵活的增加 / 删除观察者对象，而不影响其他相关对象的功能
• 总结：定义一对多的依赖关系，让多个观察者对象同时监听某一主题对象的状态变化，实现自动更新
• 场景：适用于一个对象的状态变化会影响到其他对象，并且希望这些对象在状态变化时能够自动更新的情况