北京网站制作公司,如何编写一个软件,怎样建设自己的ip地址网站,网站建设属于无形资产吗设计模式-观察者模式#xff08;Observer#xff09; 一、观察者模式概述1.1 什么是观察者模式1.2 简单实现观察者模式1.3 使用观察者模式的注意事项 二、观察者模式的用途三、观察者模式实现方式3.1 使用接口实现观察者模式3.2 使用抽象类和具体子类实现观察者模式3.3 使用 … 设计模式-观察者模式Observer 一、观察者模式概述1.1 什么是观察者模式1.2 简单实现观察者模式1.3 使用观察者模式的注意事项 二、观察者模式的用途三、观察者模式实现方式3.1 使用接口实现观察者模式3.2 使用抽象类和具体子类实现观察者模式3.3 使用 Java 内置的 Observable 和 Observer 类实现观察者模式3.4 使用事件监听器实现观察者模式3.5 使用发布-订阅模式实现观察者模式 一、观察者模式概述
1.1 什么是观察者模式
观察者模式Observer Pattern是一种行为型设计模式它定义了一种一对多的依赖关系让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时会通知所有观察者对象使它们能够自动更新自己。
观察者模式包含以下角色
主题Subject被观察的对象维护一个观察者列表提供添加、删除和通知观察者的方法。 观察者Observer观察主题对象的状态变化实现 Update 方法来更新自己的状态。 具体主题ConcreteSubject继承自抽象主题实现具体业务逻辑。 具体观察者ConcreteObserver继承自抽象观察者实现具体业务逻辑。 使用观察者模式可以使得系统更加灵活、可扩展减少各个模块之间的耦合度。
1.2 简单实现观察者模式
Java观察者模式是一种行为设计模式它定义了一种一对多的依赖关系让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时会通知所有观察者对象使它们能够自动更新自己。
以下是一个简单的Java观察者模式实现
首先创建一个观察者接口Observer包含一个update方法用于在主题状态发生变化时更新观察者的状态
public interface Observer {void update(String message);
}然后创建一个主题接口Subject包含添加、删除和通知观察者的方法
import java.util.ArrayList;
import java.util.List;public interface Subject {void addObserver(Observer observer);void removeObserver(Observer observer);void notifyObservers(String message);
}接下来创建一个具体的主题类ConcreteSubject实现Subject接口
public class ConcreteSubject implements Subject {private ListObserver observers new ArrayList();private String state;Overridepublic void addObserver(Observer observer) {observers.add(observer);}Overridepublic void removeObserver(Observer observer) {observers.remove(observer);}Overridepublic void notifyObservers(String message) {for (Observer observer : observers) {observer.update(message);}}public void setState(String state) {this.state state;notifyObservers(State changed to: state);}
}最后创建一个具体的观察者类ConcreteObserver实现Observer接口
public class ConcreteObserver implements Observer {private String name;private String state;public ConcreteObserver(String name) {this.name name;}Overridepublic void update(String message) {System.out.println(name received message: message);state message;}
}使用示例:
public class Main {public static void main(String[] args) {ConcreteSubject subject new ConcreteSubject();Observer observer1 new ConcreteObserver(Observer1);Observer observer2 new ConcreteObserver(Observer2);Observer observer3 new ConcreteObserver(Observer3);subject.addObserver(observer1);subject.addObserver(observer2);subject.addObserver(observer3);subject.setState(New State);}
}运行上述代码可以看到三个观察者对象分别接收到了主题状态变化的通知。
1.3 使用观察者模式的注意事项
1、主题对象和观察者对象的耦合度要尽可能低避免出现循环引用的情况。2、主题对象的通知方式要保持一致避免出现通知失败或者丢失的情况。3、观察者对象的 Update 方法的实现要避免过于复杂尽量保持简单易懂。4、在添加、删除观察者对象时要考虑到线程安全问题可以使用同步机制来保证线程安全。5、当主题对象的状态变化较为频繁时可能会导致大量的通知操作从而影响系统的性能。在这种情况下可以考虑使用异步消息队列等技术来优化性能。
二、观察者模式的用途
1、实现了对象之间的解耦。主题对象和观察者对象的耦合度尽可能低避免了循环引用的情况。2、支持一种一对多的依赖关系。一个主题对象状态改变时所有依赖于它的观察者对象都会被自动通知并更新。3、帮助编写更加松耦合的代码及实现事件的广播通知。尤其在主题对象的状态变化较为频繁时通过使用观察者模式可以避免大量的通知操作影响系统性能。4、适用于多种场景包括但不限于GUI应用程序、事件处理系统等。如在Java自带的观察者模式中JDK提供了Observer接口作为监听者Observable类作为观察者的实现。5、对高度协作提供了支持。当一个对象目标对象的状态发生改变时所有的依赖对象观察者对象都将得到通知进行广播通知。
三、观察者模式实现方式
3.1 使用接口实现观察者模式
观察者模式是一种行为设计模式它定义了一种一对多的依赖关系让多个观察者对象同时监听某一个主题对象。当主题对象的状态发生变化时所有依赖于它的观察者对象都会得到通知并自动更新。
下面是使用 Java 接口实现观察者模式的示例代码
// 定义观察者接口
interface Observer {void update(String message);
}// 定义主题接口
interface Subject {void addObserver(Observer observer);void removeObserver(Observer observer);void notifyObservers();
}// 具体主题类
class ConcreteSubject implements Subject {private ListObserver observers new ArrayList();private String state;public void setState(String state) {this.state state;notifyObservers();}Overridepublic void addObserver(Observer observer) {observers.add(observer);}Overridepublic void removeObserver(Observer observer) {observers.remove(observer);}Overridepublic void notifyObservers() {for (Observer observer : observers) {observer.update(state);}}
}// 具体观察者类
class ConcreteObserver implements Observer {private String name;public ConcreteObserver(String name) {this.name name;}Overridepublic void update(String message) {System.out.println(Observer name received message: message);}
}// 测试代码
public class Main {public static void main(String[] args) {ConcreteSubject subject new ConcreteSubject();Observer observer1 new ConcreteObserver(A);Observer observer2 new ConcreteObserver(B);Observer observer3 new ConcreteObserver(C);subject.addObserver(observer1);subject.addObserver(observer2);subject.addObserver(observer3);subject.setState(New State);}
}在上面的示例中我们首先定义了两个接口 Observer 和 Subject分别表示观察者和主题。然后我们创建了一个具体的主题类 ConcreteSubject它实现了 Subject 接口并维护了一个观察者列表。当主题的状态发生变化时它会调用 notifyObservers 方法通知所有的观察者。我们还创建了一个具体的观察者类 ConcreteObserver它实现了 Observer 接口并在接收到通知时打印一条消息。最后在测试代码中我们创建了一个主题对象和三个观察者对象并将它们添加到主题的观察者列表中。当我们设置主题的状态时所有的观察者都会收到通知并打印出相应的消息。
3.2 使用抽象类和具体子类实现观察者模式
观察者模式是一种行为设计模式它定义了一种一对多的依赖关系让多个观察者对象同时监听某一个主题对象。当主题对象的状态发生变化时所有依赖于它的观察者对象都会得到通知并自动更新。
下面是使用抽象类和具体子类实现观察者模式的示例代码
// 定义观察者接口
interface Observer {void update(String message);
}// 定义主题接口
interface Subject {void addObserver(Observer observer);void removeObserver(Observer observer);void notifyObservers();
}// 具体主题类
class ConcreteSubject implements Subject {private ListObserver observers new ArrayList();private String state;public void setState(String state) {this.state state;notifyObservers();}Overridepublic void addObserver(Observer observer) {observers.add(observer);}Overridepublic void removeObserver(Observer observer) {observers.remove(observer);}Overridepublic void notifyObservers() {for (Observer observer : observers) {observer.update(state);}}
}// 具体观察者类A
class ConcreteObserverA implements Observer {private String name;public ConcreteObserverA(String name) {this.name name;}Overridepublic void update(String message) {System.out.println(Observer A received message: message);}
}// 具体观察者类B
class ConcreteObserverB implements Observer {private String name;public ConcreteObserverB(String name) {this.name name;}Overridepublic void update(String message) {System.out.println(Observer B received message: message);}
}// 测试代码
public class Main {public static void main(String[] args) {ConcreteSubject subject new ConcreteSubject();Observer observerA new ConcreteObserverA(A);Observer observerB new ConcreteObserverB(B);subject.addObserver(observerA);subject.addObserver(observerB);subject.setState(New State);}
}在上面的示例中我们首先定义了观察者接口 Observer 和主题接口 Subject然后创建了一个具体的主题类 ConcreteSubject它实现了 Subject 接口并维护了一个观察者列表。当主题的状态发生变化时它会调用 notifyObservers 方法通知所有的观察者。我们还创建了两个具体的观察者类 ConcreteObserverA 和 ConcreteObserverB它们都实现了 Observer 接口并在接收到通知时打印出相应的消息。最后在测试代码中我们创建了一个主题对象和两个观察者对象并将它们添加到主题的观察者列表中。当我们设置主题的状态时所有的观察者都会收到通知并打印出相应的消息。
3.3 使用 Java 内置的 Observable 和 Observer 类实现观察者模式
要使用Java内置的Observable和Observer类实现观察者模式首先需要创建一个继承要使用Java内置的Observable和Observer类实现观察者模式首先需要创建一个继承自Observable的类然后在该类中定义一个或多个状态变量。当这些状态变量发生变化时调用setChanged()方法通知所有观察者。接下来创建一个继承自Observer的类重写update()方法以处理状态变化的通知。
以下是一个简单的示例
创建一个继承自Observable的类例如Subject
import java.util.Observable;public class Subject extends Observable {private String state;public String getState() {return state;}public void setState(String state) {this.state state;setChanged(); // 通知观察者状态已改变notifyObservers(state); // 传递新状态给观察者}
}创建一个继承自Observer的类例如MyObserver
import java.util.Observer;public class MyObserver implements Observer {Overridepublic void update(Observable o, Object arg) {if (o instanceof Subject) {System.out.println(状态已更新为 arg);}}
}在主程序中使用这两个类
public class Main {public static void main(String[] args) {Subject subject new Subject();MyObserver observer new MyObserver();subject.addObserver(observer); // 添加观察者subject.setState(状态1); // 设置状态并通知观察者subject.setState(状态2); // 设置状态并通知观察者}
}运行上述代码将看到以下输出:
状态已更新为状态1
状态已更新为状态23.4 使用事件监听器实现观察者模式
在Java中可以使用事件监听器实现观察者模式。以下是一个简单的示例
首先创建一个事件类Event用于传递事件信息
public class Event {private Object source;public Event(Object source) {this.source source;}public Object getSource() {return source;}
}然后创建一个事件监听器接口EventListener用于处理事件
public interface EventListener {void handleEvent(Event event);
}接下来创建一个具体的事件源类EventSource用于注册和触发事件
import java.util.ArrayList;
import java.util.List;public class EventSource {private ListEventListener listeners new ArrayList();public void addEventListener(EventListener listener) {listeners.add(listener);}public void removeEventListener(EventListener listener) {listeners.remove(listener);}public void fireEvent(Event event) {for (EventListener listener : listeners) {listener.handleEvent(event);}}
}最后创建一个具体的观察者类ConcreteObserver实现EventListener接口
public class ConcreteObserver implements EventListener {Overridepublic void handleEvent(Event event) {System.out.println(收到事件 event.getSource());}
}在主程序中使用这些类
public class Main {public static void main(String[] args) {EventSource eventSource new EventSource();ConcreteObserver observer new ConcreteObserver();eventSource.addEventListener(observer);eventSource.fireEvent(new Event(事件1));eventSource.fireEvent(new Event(事件2));}
}运行上述代码将看到以下输出
收到事件事件1
收到事件事件23.5 使用发布-订阅模式实现观察者模式
在Java中可以使用java.util.Observable类和java.util.Observer接口实现发布-订阅模式。以下是一个简单的示例
首先创建一个继承自java.util.Observable的类例如Publisher
import java.util.Observable;public class Publisher extends Observable {private String message;public void setMessage(String message) {this.message message;setChanged(); // 标记状态已改变notifyObservers(message); // 通知所有观察者}
}然后创建一个实现java.util.Observer接口的类例如Subscriber
import java.util.Observer;public class Subscriber implements Observer {private String name;public Subscriber(String name) {this.name name;}Overridepublic void update(Observable o, Object arg) {System.out.println(name 收到消息 arg);}
}最后在主程序中使用这两个类
public class Main {public static void main(String[] args) {Publisher publisher new Publisher();Subscriber subscriber1 new Subscriber(订阅者1);Subscriber subscriber2 new Subscriber(订阅者2);publisher.addObserver(subscriber1);publisher.addObserver(subscriber2);publisher.setMessage(Hello, World!);}
}运行这个程序你将看到以下输出
订阅者1收到消息 Hello, World!
订阅者2收到消息 Hello, World!
