菜鸟教程 -- 学的不仅是技术,更是梦想!

设计模式
(追記) (追記ここまで)

观察者模式

观察者模式是一种行为型设计模式,它定义了一种一对多的依赖关系,当一个对象的状态发生改变时,其所有依赖者都会收到通知并自动更新。

当对象间存在一对多关系时,则使用观察者模式(Observer Pattern)。比如,当一个对象被修改时,则会自动通知依赖它的对象。观察者模式属于行为型模式。

介绍

意图

创建了对象间的一种一对多的依赖关系,当一个对象状态改变时,所有依赖于它的对象都会得到通知并自动更新。。

主要解决的问题

  • 观察者模式解决的是一个对象状态改变时,如何自动通知其他依赖对象的问题,同时保持对象间的低耦合和高协作性。

使用场景

  • 当一个对象的状态变化需要同时更新其他对象时。

实现方式

  • 定义观察者接口:包含一个更新方法。
  • 创建具体观察者:实现观察者接口,定义接收到通知时的行为。
  • 定义主题接口:包含添加、删除和通知观察者的方法。
  • 创建具体主题:实现主题接口,管理观察者列表,并在状态改变时通知它们。

关键代码

  • 观察者列表:在主题中维护一个观察者列表。

应用实例

  • 拍卖系统:拍卖师作为主题,竞价者作为观察者,拍卖价格更新时通知所有竞价者。
  • 西游记故事:菩萨洒水作为状态改变,老乌龟作为观察者,观察到这一变化。

优点

  • 抽象耦合:观察者和主题之间是抽象耦合的。
  • 触发机制:建立了一套状态改变时的触发和通知机制。

缺点

  • 性能问题:如果观察者众多,通知过程可能耗时。
  • 循环依赖:可能导致循环调用和系统崩溃。
  • 缺乏变化详情:观察者不知道主题如何变化,只知道变化发生。

使用建议

  • 在需要降低对象间耦合度,并且对象状态变化需要触发其他对象变化时使用。
  • 考虑使用Java内置的观察者模式支持类,如java.util.Observable和java.util.Observer。

注意事项

  • 避免循环引用:注意观察者和主题之间的依赖关系,避免循环引用。
  • 异步执行:考虑使用异步通知避免单点故障导致整个系统卡壳。

结构

观察者模式包含以下几个核心角色:

  • 主题(Subject):也称为被观察者或可观察者,它是具有状态的对象,并维护着一个观察者列表。主题提供了添加、删除和通知观察者的方法。
  • 观察者(Observer):观察者是接收主题通知的对象。观察者需要实现一个更新方法,当收到主题的通知时,调用该方法进行更新操作。
  • 具体主题(Concrete Subject):具体主题是主题的具体实现类。它维护着观察者列表,并在状态发生改变时通知观察者。
  • 具体观察者(Concrete Observer):具体观察者是观察者的具体实现类。它实现了更新方法,定义了在收到主题通知时需要执行的具体操作。

观察者模式通过将主题和观察者解耦,实现了对象之间的松耦合。当主题的状态发生改变时,所有依赖于它的观察者都会收到通知并进行相应的更新。

实现

观察者模式使用三个类 Subject、Observer 和 Client。Subject 对象带有绑定观察者到 Client 对象和从 Client 对象解绑观察者的方法。我们创建 Subject 类、Observer 抽象类和扩展了抽象类 Observer 的实体类。

ObserverPatternDemo,我们的演示类使用 Subject 和实体类对象来演示观察者模式。

观察者模式的 UML 图

步骤 1

创建 Subject 类。

Subject.java

importjava.util.ArrayList; importjava.util.List; publicclassSubject{privateList<Observer> observers = newArrayList<Observer>(); privateintstate; publicintgetState(){returnstate; }publicvoidsetState(intstate){this.state = state; notifyAllObservers(); }publicvoidattach(Observerobserver){observers.add(observer); }publicvoidnotifyAllObservers(){for(Observerobserver : observers){observer.update(); }}}

步骤 2

创建 Observer 类。

Observer.java

publicabstractclassObserver{protectedSubjectsubject; publicabstractvoidupdate(); }

步骤 3

创建实体观察者类。

BinaryObserver.java

publicclassBinaryObserverextendsObserver{publicBinaryObserver(Subjectsubject){this.subject = subject; this.subject.attach(this); } @Overridepublicvoidupdate(){System.out.println("Binary String: " + Integer.toBinaryString(subject.getState())); }}

OctalObserver.java

publicclassOctalObserverextendsObserver{publicOctalObserver(Subjectsubject){this.subject = subject; this.subject.attach(this); } @Overridepublicvoidupdate(){System.out.println("Octal String: " + Integer.toOctalString(subject.getState())); }}

HexaObserver.java

publicclassHexaObserverextendsObserver{publicHexaObserver(Subjectsubject){this.subject = subject; this.subject.attach(this); } @Overridepublicvoidupdate(){System.out.println("Hex String: " + Integer.toHexString(subject.getState()).toUpperCase()); }}

步骤 4

使用 Subject 和实体观察者对象。

ObserverPatternDemo.java

publicclassObserverPatternDemo{publicstaticvoidmain(String[]args){Subjectsubject = newSubject(); newHexaObserver(subject); newOctalObserver(subject); newBinaryObserver(subject); System.out.println("First state change: 15"); subject.setState(15); System.out.println("Second state change: 10"); subject.setState(10); }}

步骤 5

执行程序,输出结果:

First state change: 15
Hex String: F
Octal String: 17
Binary String: 1111
Second state change: 10
Hex String: A
Octal String: 12
Binary String: 1010
AI 思考中...

11 篇笔记 写笔记

  1. #0

    fatcheung

    134***[email protected]

    124

    观察者模式,我理解的就是观察者订阅被观察者的状态,当被观察者状态改变的时候会通知所有订阅的观察者的过程。所以以下这种写法会不会更加容易理解一些呢?

    观察者接口:

    public abstract class Observer { 
 public abstract void update(String msg);
}

    第一个观察者:

    public class F_Observer extends Observer {
 public void update(String msg) {
 System.out.println(F_Observer.class.getName() + " : " + msg);
 }
}

    第二个观察者:

    public class S_Observer extends Observer {
 public void update(String msg) {
 System.out.println(S_Observer.class.getName() + " : " + msg);
 }
}

    第三个观察者:

    public class T_Observer extends Observer {
 public void update(String msg) {
 System.out.println(T_Observer.class.getName() + " : " + msg);
 }
}

    被观察者:

    public class Subject { 
 private List<Observer> observers = new ArrayList<>(); //状态改变 
 public void setMsg(String msg) { 
 notifyAll(msg); 
 } 
 //订阅 
 public void addAttach(Observer observer) { 
 observers.add(observer); 
 } 
 //通知所有订阅的观察者 
 private void notifyAll(String msg) { 
 for (Observer observer : observers) { 
 observer.update(msg); 
 } 
 }
}

    使用方法:

    public class Main { 
 public static void main(String[] args) { 
 F_Observer fObserver = new F_Observer(); 
 S_Observer sObserver = new S_Observer(); 
 T_Observer tObserver = new T_Observer(); 
 Subject subject = new Subject(); 
 subject.addAttach(fObserver); 
 subject.addAttach(sObserver); 
 subject.addAttach(tObserver); 
 subject.setMsg("msg change"); 
 }
}
    运行结果: test.F_Observer : msg changetest.S_Observer : msg changetest.T_Observer : msg change

    fatcheung

    134***[email protected]

    8年前 (2018年02月23日)
  2. #0

    DHclly

    335***[email protected]

    11

    用 C# 实现了示例并优化了一下:

    Subject.cs

    public class Subject
{
 private readonly List<Observer> _observers = new List<Observer>();
 private int _state;
 public int State
 {
 get => _state;
 set
 {
 _state = value;
 NotifyAllObservers();
 }
 }
 public void AddObserver(Observer observer)
 {
 observer.Subject = this;
 _observers.Add(observer);
 }
 public void NotifyAllObservers() => _observers.ForEach(o => o.Update());
}

    Observer.cs

    public abstract class Observer
{
 public Subject Subject;
 
 public abstract void Update();
}

    BinaryObserver.cs

    public class BinaryObserver:Observer
{
 public BinaryObserver()
 {
 
 }
 public BinaryObserver(Subject subject)
 {
 subject.AddObserver(this);
 }
 public override void Update()
 {
 Console.WriteLine($"Binary String: {Convert.ToString(Subject.State, 2)}");
 }
}

    OctalObserver.cs

    public class OctalObserver:Observer
{
 public OctalObserver()
 {
 
 }
 public OctalObserver(Subject subject)
 {
 subject.AddObserver(this);
 }
 public override void Update()
 {
 Console.WriteLine($"Octal String: {Convert.ToString(Subject.State, 8)}");
 }
}

    HexaObserver.cs

    public class HexaObserver:Observer
{
 public HexaObserver()
 {
 
 }
 public HexaObserver(Subject subject)
 {
 subject.AddObserver(this);
 }
 public override void Update()
 {
 Console.WriteLine($"Hex String: {Convert.ToString(Subject.State, 16)}");
 }
}

    Demo.cs

    public void NumberChange()
{
 Subject subject1 = new Subject();
 new BinaryObserver(subject1);
 new OctalObserver(subject1);
 new HexaObserver(subject1);
 Console.WriteLine("1 state=15");
 subject1.State = 15;
 Console.WriteLine("1 state=10");
 subject1.State = 10;
 Subject subject2 = new Subject();
 subject2.AddObserver(new BinaryObserver());
 subject2.AddObserver(new OctalObserver());
 subject2.AddObserver(new HexaObserver(subject1));
 Console.WriteLine("2 state=15");
 subject1.State = 15;
 Console.WriteLine("2 state=10");
 subject1.State = 10;
}

    DHclly

    335***[email protected]

    8年前 (2018年08月06日)
  3. #0

    jade

    guo***[email protected]

    20

    Observer 模式的定义:该模式定义了对象之间的一对多依赖关系,Subject 对象是一,Observer 对象是多。当 Subject 对象的状态发生改变时,所有依赖于该 Subject 对象的 Observer 对象都会得到通知,并且自动更新。

    仔细分析定义,要精确理解观察者模式主要注意三点:

    1.定义了对象间的一对多依赖关系;

    2.当 Subject 对象的状态发生改变时,所有依赖于该 Subject 对象的 Observer 对象都会得到通知;

    3.Observer 对象得到通知后,会自动更新,而不是被动;

    其它的所有点都是细枝末节,由具体业务需求来决定。比如:

    1. Subject 角色是应该定义成类?比如 内置的 java.util.Observable;还是应该定义成接口,以规避Java不支持多重继承的问题?比如《Head First 设计模式》中的推荐作法。

    2.应该在什么时候订阅主题(或者说注册观察者)?是实例化观察者对象的同时?比如贴主的示例;还是由客户自主决定?比如此贴的第一篇分享笔记。

    3.是否应该实现取消订阅功能(或者说取消注册)?

    4.主题对象通知观察者时,是否携带消息?换句话说,是"推"消息?如贴主示例;还是"拉"消息?

    5.是否支持多线程?

    jade

    guo***[email protected]

    8年前 (2018年09月19日)
  4. #0

    看了上面的代码,用 kotlin 实现了一下:

    /**
 * 观察者
 */
interface Observer {
 fun <T : Any?> update(msg: T)
}
 
/**
 * 观察者1,2,3
 */
class Ob1(private val id: Int = 0) : Observer {
 override fun <T> update(msg: T) {
 println("接收消息,观察者$id:$msg")
 }
}
//这里是kotlin的类委托
class Ob2 : Observer by Ob1(2)
class Ob3 : Observer by Ob1(3)
 
/**
 * 被观察者(订阅者)
 */
class Subject {
 
 //存放观察者
 private var observers = ArrayList<Observer>()
 //订阅观察者
 fun attach(ob: Observer) {
 observers.add(ob)
 }
 //设置数据
 fun <T : Any?> setMsg(msg: T) {
 this.notify(msg)
 }
 //更新数据
 private fun <T : Any?> notify(msg: T) {
 for (iOb in this.observers) {
 iOb.update(msg)
 }
 }
}
 
/**
 * Kotlin版 观察者模式
 * @author IWH
 * Des:kotlin1.3支持主函数省略参数
 */
fun main() {
 
 val sub = Subject().apply {
 attach(Ob1())
 attach(Ob2())
 attach(Ob3())
 }
 with(sub){
 setMsg(123)
 setMsg("hello world")
 setMsg('A')
 setMsg(null)
 }
}
    7年前 (2019年04月11日)
  5. #0

    shenshaonian

    134***[email protected]

    5

    观音洒水

    public class TortoisObserverDemo {
 public static void main(String[] args){
 GuanYin guanYin = new GuanYin();
 new SmallTortoise(guanYin);
 new BigTortoise(guanYin);
 guanYin.watering();
 }
}
public class GuanYin {
 private List<Observer> observers = new ArrayList<Observer>();
 public void watering(){
 System.out.println("观音洒水");
 notifyAllTortoise();
 }
 private void notifyAllTortoise() {
 int i = 0;
 for (Observer o:observers) {
 o.flyToGuanYin();
 System.out.println(++i);
 }
 }
 public void attach(Observer observer) {
 observers.add(observer);
 }
}
public abstract class Observer {
 protected GuanYin guanYin;
 protected abstract void flyToGuanYin();
}
public class SmallTortoise extends Observer {
 public SmallTortoise(GuanYin guanYin) {
 this.guanYin = guanYin;
 this.guanYin.attach(this);
 }
 @Override
 protected void flyToGuanYin() {
 System.out.println("SmallTortoise fly to guanyin");
 }
}
public class BigTortoise extends Observer {
 public BigTortoise(GuanYin guanYin) {
 this.guanYin = guanYin;
 this.guanYin.attach(this);
 }
 @Override
 protected void flyToGuanYin() {
 System.out.println("BigTortoise fly to guanyin");
 }
}

    shenshaonian

    134***[email protected]

    7年前 (2019年05月17日)
  6. #0

    郭艺宾

    guo***[email protected]

    8

    利用JDK实现观察者模式,在一对多中,一方代码:

    import java.util.Observable;
public class Subject extends Observable {
 private int state;
 public int getState() {
 return state;
 }
 public void setState(int state) {
 this.state = state;
 this.setChanged();
 this.notifyObservers();
 }
}

    多方代码:

    import java.util.Observable;
import java.util.Observer;
public class BinaryObserver implements Observer {
 public BinaryObserver(Observable observable) {
 observable.addObserver(this);
 }
 @Override
 public void update(Observable o, Object arg) {
 if (o instanceof Subject) {
 System.out.println("Binary String: " + Integer.toBinaryString(((Subject) o).getState()));
 }
 }
}
    import java.util.Observable;
import java.util.Observer;
public class HexaObserver implements Observer {
 public HexaObserver(Observable observable) {
 observable.addObserver(this);
 }
 @Override
 public void update(Observable o, Object arg) {
 if (o instanceof Subject) {
 System.out.println("Binary String: " + Integer.toHexString(((Subject) o).getState()));
 }
 }
}
    import java.util.Observable;
import java.util.Observer;
public class OctalObserver implements Observer {
 public OctalObserver(Observable observable) {
 observable.addObserver(this);
 }
 @Override
 public void update(Observable o, Object arg) {
 if (o instanceof Subject) {
 System.out.println("Binary String: " + Integer.toOctalString(((Subject) o).getState()));
 }
 }
}

    运行测试类:

    public class ObserverPatternDemo {
 public static void main(String[] args) {
 Subject subject = new Subject();
 new BinaryObserver(subject);
 new OctalObserver(subject);
 new HexaObserver(subject);
 System.out.println("First state change: 15");
 subject.setState(15);
 System.out.println("Second state change: 10");
 subject.setState(10);
 }
}

    运行结果:

    First state change: 15
Binary String: f
Binary String: 17
Binary String: 1111
Second state change: 10
Binary String: a
Binary String: 12
Binary String: 1010

    郭艺宾

    guo***[email protected]

    7年前 (2019年06月28日)
  7. #0

    infiniteH

    212***[email protected]

    10

    被观察对象与观察者对象

    一个被观察对象关联多个观察者对象

    所以,被观察对象有个容器,去存储观察者对象

    观察者对象也有一个被观察对象的成员变量

    当被观察对象的某个属性发生改变,想让所以与之关联的观察者对象作出响应,就在改变属性的方法中,调用通知方法,所以需要声明一个通知方法,就是遍历所有观察者,调用一个观察者都有的方法,也就是update更新方法。

    本质就是在更改某个属性后,遍历所有元素的某个方法,其实也就是多态

    infiniteH

    212***[email protected]

    6年前 (2020年02月29日)
  8. #0

    Siskin.xu

    sis***@sohu.com

    3

    Python 方式:

    # Observer Pattern with Python Code
from abc import abstractmethod,ABCMeta
# 创建一个目标对象Subject,如果有多种不同的目标,可以抽象subject,用子对象实现
class Subject:
 # 建立一个私有集合,存放观察者对象
 _observers = []
 _state = ""
 def getState(self):
 return self._state
 def setState(self,inState):
 self._state = inState
 self.notifyAllObservers()
 # 追加观察者
 def attach(self, inObserver):
 self._observers.append(inObserver)
 # 通知观察者
 def notifyAllObservers(self):
 for aObser in self._observers :
 aObser.update()
# 创建观察者抽象类
class Observer(metaclass=ABCMeta):
 subject = Subject()
 @abstractmethod
 def update(self):
 pass
 def __init__(self):
 self.subject = Subject()
# 实现具体观察者
class BinaryObserver(Observer):
 def __init__(self,inSubject):
 self.subject = inSubject
 self.subject.attach(self)
 def update(self):
 print("Binary String : " + str(bin(self.subject.getState())))
class OctalObserver(Observer):
 def __init__(self,inSubject):
 self.subject = inSubject
 self.subject.attach(self)
 def update(self):
 print("Octal String : " + str(oct(self.subject.getState())))
class HexaObserver(Observer):
 def __init__(self,inSubject):
 self.subject = inSubject
 self.subject.attach(self)
 def update(self):
 print("Hex String : " + str(hex(self.subject.getState())))
# 调用输出
if __name__ == '__main__':
 aSubject = Subject()
 HexaObserver(aSubject)
 OctalObserver(aSubject)
 BinaryObserver(aSubject)
 print("First state change : 15")
 aSubject.setState(15);
 print("======================")
 print("First state change : 10")
 aSubject.setState(10);

    Siskin.xu

    sis***@sohu.com

    6年前 (2020年02月29日)
  9. #0

    glory

    809***[email protected]

    2

    你的观察者和被观察者有组合关系不好,可以改成依赖关系:

    public class Subject { 
 private List observers = new ArrayList(); 
 public void addObserver(Observer observer){ 
 observers.add(observer); 
 } 
 protected void notifyObservers(){ 
 for (Observer o:observers){ 
 o.update(this); 
 } 
 }
}
public abstract class Observer { 
 private Action action; 
 /** * subject 观察谁 ,action 发生变化做什么 */ 
 public void observe(E subject,Action action){ 
 subject.addObserver(this); 
 this.action=action; 
 } 
 public void update(Subject subject){ 
 this.action.update(subject); 
 } 
 public interface Action{ 
 void update(E subject); 
 }
}
public class Patient extends Subject { 
 private int age; 
 private String disease; 
 public Patient(int age, String disease) { 
 this.age = age; 
 this.disease = disease; 
 } 
 public void setAge(int age) { 
 this.age = age; 
 this.notifyObservers(); 
 } 
 public void setDisease(String disease) { 
 this.disease = disease; 
 this.notifyObservers(); 
 } 
 public int getAge() { 
 return age; 
 } 
 public String getDisease() { 
 return disease; 
 }
}
public class Doctor extends Observer {}
public class Test { 
 public static void main(String[] args) { 
 Patient patient = new Patient(10,"高血压"); 
 new Doctor().observe(patient,
 (subject)-> System.out.println("医生观察到患者变化:年龄-"+subject.getAge()+"岁,疾病-"+subject.getDisease()) ); 
 new Nurse().observe(patient, 
 (subject)-> System.out.println("护士观察到患者变化:年龄-"+subject.getAge()+"岁,疾病-"+subject.getDisease())); 
 System.out.println("============变化1========"); 
 patient.setAge(20); 
 System.out.println("============变化2========"); 
 patient.setDisease("糖尿病"); 
 }
}
public class Nurse extends Observer {}

    输出结果:

    ============变化1========
医生观察到患者变化:年龄-20岁,疾病-高血压
护士观察到患者变化:年龄-20岁,疾病-高血压
============变化2========
医生观察到患者变化:年龄-20岁,疾病-糖尿病
护士观察到患者变化:年龄-20岁,疾病-糖尿病

    glory

    809***[email protected]

    4年前 (2022年11月04日)
  10. #0

    失业

    gjh***[email protected]

    1

    这样写好像更容易理解。

    public class Subject {
 private List observers = new ArrayList();
 private int state;
 public int getState() {
 return state;
 }
 public void setState(int state) {
 this.state = state;
 }
 public void addObserver(Observer observer) {
 observers.add(observer);
 }
 public void notifyAllObservers() {
 for (Observer observer : observers) {
 observer.update(this);
 }
 }
} 
public abstract class Observer {
 public abstract void update(Subject subject);
} 
 
public class HexaObserver extends Observer{
 @Override
 public void update(Subject subject) {
 System.out.println( "Hex String: " + Integer.toHexString( subject.getState() ).toUpperCase() );
 }
} 
 
public class ObserverPatternDemo {
 public static void main(String[] args) {
 Subject subject = new Subject();
 subject.addObserver(new HexaObserver());
 subject.addObserver(new OctalObserver());
 subject.addObserver(new BinaryObserver());
 System.out.println("First state change: 15");
 subject.setState(15);
 subject.notifyAllObservers();
 System.out.println("Second state change: 10");
 subject.setState(10);
 subject.notifyAllObservers();
 }
}

    失业

    gjh***[email protected]

    3年前 (2023年02月17日)
  11. #0

    RUNOOB

    429***[email protected]

    2

    观察者模式可以实现松耦合,使得主题和观察者之间的关系更加灵活。它可以方便地添加新的观察者,以及在运行时动态地增加、删除或修改观察者。同时,观察者模式符合开闭原则,使得主题和观察者可以独立变化,而不会相互影响。

    下面是一个简单的观察者模式示例,假设有一个天气监测系统,主题是天气数据,观察者是不同的显示设备,它们实时显示天气数据的变化:

    // 主题 - 天气数据
interface WeatherData {
 void registerObserver(WeatherObserver observer);
 void removeObserver(WeatherObserver observer);
 void notifyObservers();
}
// 观察者 - 显示设备
interface WeatherObserver {
 void update(float temperature, float humidity, float pressure);
}
// 具体主题 - 天气数据
class WeatherStation implements WeatherData {
 private List<WeatherObserver> observers;
 private float temperature;
 private float humidity;
 private float pressure;
 public WeatherStation() {
 this.observers = new ArrayList<>();
 }
 public void registerObserver(WeatherObserver observer) {
 observers.add(observer);
 }
 public void removeObserver(WeatherObserver observer) {
 observers.remove(observer);
 }
 public void notifyObservers() {
 for (WeatherObserver observer : observers) {
 observer.update(temperature, humidity, pressure);
 }
 }
 public void setMeasurements(float temperature, float humidity, float pressure) {
 this.temperature = temperature;
 this.humidity = humidity;
 this.pressure = pressure;
 notifyObservers();
 }
}
// 具体观察者 - 显示设备
class DisplayDevice implements WeatherObserver {
 private String name;
 public DisplayDevice(String name) {
 this.name = name;
 }
 public void update(float temperature, float humidity, float pressure) {
 System.out.println(name + " - Temperature: " + temperature +
 " Humidity: " + humidity + " Pressure: " + pressure);
 }
}
// 客户端代码
public class Main {
 public static void main(String[] args) {
 WeatherStation weatherStation = new WeatherStation();
 DisplayDevice display1 = new DisplayDevice("Display 1");
 DisplayDevice display2 = new DisplayDevice("Display 2");
 weatherStation.registerObserver(display1);
 weatherStation.registerObserver(display2);
 weatherStation.setMeasurements(25.5f, 65.2f, 1013.2f);
 // Output:
 // Display 1 - Temperature: 25.5 Humidity: 65.2 Pressure: 1013.2
 // Display 2 - Temperature: 25.5 Humidity: 65.2 Pressure: 1013.2
 weatherStation.removeObserver(display2);
 weatherStation.setMeasurements(27.8f, 62.8f, 1010.5f);
 // Output:
 // Display 1 - Temperature: 27.8 Humidity: 62.8 Pressure: 1010.5
 }
}

    在上面的示例中,我们定义了主题接口 WeatherData 和观察者接口 WeatherObserver,具体主题类 WeatherStation 和具体观察者类 DisplayDevice。通过注册观察者、更新状态和通知观察者的过程,实现了主题和观察者之间的交互。

    RUNOOB

    429***[email protected]

    3年前 (2023年07月11日)

点我分享笔记

  • 昵称 (必填)
  • 邮箱 (必填)
  • 引用地址

AltStyle によって変換されたページ (->オリジナル) /