第14章《观察者模式》

分类：设计模式作者：编程之家用户

的依赖关系，让多个观察者对象同事监听某一个主题的对象。这个主题对象在状态在发生变化时，会通知所有的观察者对象，让它们能够。

/**


    

  • 

    @Author: cxh
    

    • 

  • 

    @CreateTime: 18/1/10 09:08
    

    • 

  • 

    @ProjectName: JavaBaseTest
    
*/
    
public class Client {
    
public static void main(String[] args) {
    
Boss boss=new Boss();
    
NBAObserver nbaObserver=new NBAObserver("李明浩",boss);
    
TVObserver tvObserver=new TVObserver("李沁",boss);
    
//add
    
boss.add(nbaObserver);
    
boss.add(tvObserver);
    
//delete
    

     //boss状态转变,通知观察者
 boss.setSubjetctState("领导回来了");
 boss.notifyObservers();
    

    }
    
}

<span style="font-size:14px;">




/**


    

  • 

    @Author: cxh
    

    • 

  • 

    @CreateTime: 18/1/9 23:29
    

    • 

  • 

    @ProjectName: JavaBaseTest
    
*/
    
public abstract class Subject {
    
abstract void add(Observer observer);
    
abstract void delete(Observer observer);
    
abstract void notifyObservers();
    
private String subjetctState;
    

    //获取主题状态
    
public String getSubjetctState() {
    
return subjetctState;
    
}
    
//设置主题状态
    
public void setSubjetctState(String subjetctState) {
    
this.subjetctState = subjetctState;
    
}
    
}

<span style="font-size:14px;">




import java.util.ArrayList;

import java.util.List;


/**


    

  • 

    @Author: cxh
    

    • 

  • 

    @CreateTime: 18/1/10 09:11
    

    • 

  • 

    @ProjectName: JavaBaseTest
    
*/
    
public class Boss extends Subject{
    
private List list=new ArrayList<>();
    

    //增加观察者
    
public void add(Observer observer){
    
list.add(observer);
    
}
    
//删除观察者
    
public void delete(Observer observer){
    
list.remove(observer);
    
}
    
//通知
    
public void notifyObservers(){
    
for(Observer s:list)
    
s.update();
    
}
    
}

<span style="font-size:14px;">




/**


    

  • @Author: cxh
    • 

  • @CreateTime: 18/1/9 23:17
    • 

  • @ProjectName: JavaBaseTest
    
*/
    
public interface Observer {
    
void update();
    
}

<span style="font-size:14px;">



/**


    

  • 

    @Author: cxh
    

    • 

  • 

    @CreateTime: 18/1/9 23:28
    

    • 

  • 

    @ProjectName: JavaBaseTest
    
*/
    
public class NBAObserver implements Observer {
    
private Subject subject;//关注主题
    
private String name;//观察者名字
    
public NBAObserver(String name,Subject subject){//参数Subject体现了:具体依赖抽象原则
    
this.name=name;
    
this.subject=subject;
    
}
    

    @Override
    
public void update() {
    
System.out.println(subject.getSubjetctState()+","+name+","+"快继续工作~");
    
}
    
}

<span style="font-size:14px;">




/**


    

  • 

    @Author: cxh
    

    • 

  • 

    @CreateTime: 18/1/9 23:45
    

    • 

  • 

    @ProjectName: JavaBaseTest
    
*/
    
public class TVObserver implements Observer {
    
private String name;//看电视的人名字
    
private Boss subject;//主题
    
public TVObserver(String name,Boss subject){
    
this.name=name;
    
this.subject=subject;
    
}
    

    @Override
    
public void update() {
    
System.out.println(subject.getSubjetctState()+","+"快继续工作~");
    
}
    
}

<span style="font-size:14px;">
输出：

Process finished with exit code 0

<span style="font-size:14px;">

import java.util.Date;


/**


    

  • 

    @Author: cxh
    

    • 

  • 

    @CreateTime: 18/1/12 16:40
    

    • 

  • 

    @ProjectName: JavaBaseTest
    
*/
    
public class Client {
    
public static void main(String[] args) {
    
//观察者.  创建时起,开始做自己的事情
    
NBAObserver nbaObserver=new NBAObserver();
    
TVObserver tvObserver=new TVObserver();
    
//主题(通知者)
    
NotifierA notifierA=new NotifierA();
    

     //为主题添加观察者
 notifierA.addListener(nbaObserver,"stopWatchingNBA",new Date());
 notifierA.addListener(tvObserver,"stopWatchingTV",new Date());

 //主题状态改变,通知观察者
 notifierA.notifyX();
    

    }
    
}

<span style="font-size:14px;">




import java.lang.reflect.Method;


/**


    

  • 

    @Author: cxh
    

    • 

  • 

    @CreateTime: 18/1/10 23:29
    

    • 

  • 

    @ProjectName: JavaBaseTest
    
*/
    
public class Event{
    
//要执行方法的对象
    
private Object object;
    
//要执行的方法名称
    
private String methodName;
    
//要执行方法的参数
    
private Object[] params;
    
//要执行方法的参数类型
    
private Class[] paramType;
    

    //两个构造函数
    
public Event(){}
    
public Event(Object object,String methodName,Object... args){
    
this.object=object;
    
this.methodName=methodName;
    
this.params=args;
    
//获取参数类型
    
getParaTypes(args);
    
}
    
private void getParaTypes(Object[] params){
    
int size=params.length;
    
this.paramType=new Class[size];//4个私有变量,只有这个变量实现了深拷贝
    
for(int i=0;i<size;i++)
    
paramType[i]=params[i].getClass();
    
}
    

    //执行该对象的方法
    
public void invoke() throws Exception{
    
Method method=object.getClass().getMethod(getMethodName(),getParamType());
    
if(null==method)
    
return;
    
method.invoke(getObject(),getParams());
    
}
    

    //get,set方法
    
public Object getObject() {
    
return object;
    
}
    

    public void setObject(Object object) {
    
this.object = object;
    
}
    

    public String getMethodName() {
    
return methodName;
    
}
    

    public void setMethodName(String methodName) {
    
this.methodName = methodName;
    
}
    

    public Object[] getParams() {
    
return params;
    
}
    

    public void setParams(Object[] params) {
    
this.params = params;
    
}
    

    public Class[] getParamType() {
    
return paramType;
    
}
    

    public void setParamType(Class[] paramType) {
    
this.paramType = paramType;
    
}
    
}

<span style="font-size:14px;">




import java.util.ArrayList;

import java.util.List;


/**


    

  • 

    @Author: cxh
    

    • 

  • 

    @CreateTime: 18/1/12 11:23
    

    • 

  • 

    @ProjectName: JavaBaseTest
    
*/
    
public class EventHandler {
    
//保存了很多event的引用
    
private List objects;
    
public EventHandler(){
    
objects=new ArrayList<>();
    
}
    

    //添加某个event
    
public void addEvent(Object object,String name,Object... args){
    
objects.add(new Event(object,name,args));
    
}
    
//触发所有引用的event
    
public void notifyEvents() throws Exception{
    
for(Event e:objects)
    
e.invoke();
    
}
    
}

<span style="font-size:14px;">




import java.util.Date;


/**


    

  • @Author: cxh
    • 

  • @CreateTime: 18/1/12 16:30
    • 

  • @ProjectName: JavaBaseTest
    
*/
    
public class NBAObserver{
    
public NBAObserver(){
    
System.out.println("正在观看NBA比赛!当前时间为:"+new Date());
    
}
    
public void stopWatchingNBA(Date date){
    
System.out.println("领导回来了,快关闭NBA赛事直播!当前时间为:"+date);
    
}
    
}

<span style="font-size:14px;">



import java.util.Date;


/**


    

  • @Author: cxh
    • 

  • @CreateTime: 18/1/12 16:37
    • 

  • @ProjectName: JavaBaseTest
    
*/
    
public class TVObserver {
    
public TVObserver(){
    
System.out.println("正在观看电视剧<<甄嬛传>>,当前时间为:"+new Date());
    
}
    
public void stopWatchingTV(Date date){
    
System.out.println("领导回来了,快关闭电视剧播放.当前时间为:"+date);
    
}
    
}

<span style="font-size:14px;">



/**


    

  • 

    @Author: cxh
    

    • 

  • 

    @CreateTime: 18/1/12 11:36
    

    • 

  • 

    @ProjectName: JavaBaseTest
    
*/
    
public abstract class Notifier {
    
private EventHandler eventHandler=new EventHandler();
    
//增加需要帮忙放哨的同事
    
public abstract void addListener(Object object,Object... args);
    
//告诉所有需要帮忙放哨的同事:领导回来啦
    
public abstract void notifyX();
    

    //get,set
    
public EventHandler getEventHandler() {
    
return eventHandler;
    
}
    

    public void setEventHandler(EventHandler eventHandler) {
    
this.eventHandler = eventHandler;
    
}
    
}

<span style="font-size:14px;">




/**


    

  • 

    @Author: cxh
    

    • 

  • 

    @CreateTime: 18/1/12 16:13
    

    • 

  • 

    @ProjectName: JavaBaseTest
    
*/
    
public class NotifierA extends Notifier{
    

    @Override
    
public void addListener(Object object,Object... args) {
    
getEventHandler().addEvent(object,args);
    
}
    

    @Override
    
public void notifyX(){
    
try{
    
getEventHandler().notifyEvents();
    
}catch (Exception e){
    
System.out.println("通知同事时出错!!!");
    
}
    
}
    
}

<span style="font-size:14px;">

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

什么是设计模式？Design pattern--和生活结合更好理解
什么是设计模式一套被反复使用、多数人知晓的、经过分类编目的、代码 设计经验 的总结；使用设计模式是为了 可重用 代码、让代码 更容易 被他人理解、保证代码 可靠性；设计模式使代码编制  真正工程化；设计模式使软件工程的 基石脉络， 如同大厦的结构一样；并不直接用来完成代码的编写，而是 描述 在各种不同情况下，要怎么解决问题的一种方案；能使不稳定依赖于相对稳定、具体依赖于相对抽象，避免引
面向对象设计原则一——单一职责原则
单一职责原则定义（Single Responsibility Principle，SRP）一个对象应该只包含 单一的职责，并且该职责被完整地封装在一个类中。Every  Object should have  a single responsibility, and that responsibility should be entirely encapsulated by t
十分钟理解Java中的动态代理----强烈推荐
动态代理和CGLib代理分不清吗，看看这篇文章，写的非常好，强烈推荐。原文截图*************************************************************************************************************************原文文本************
适配器模式-让不兼容的接口得以适配
适配器模式将一个类的接口转换成客户期望的另一个接口，使得原本接口不兼容的类可以相互合作。
策略模式-定义一个算法族
策略模式定义了一系列算法族，并封装在类中，它们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。
设计模式之高质量代码
设计模式讲的是如何编写可扩展、可维护、可读的高质量代码，它是针对软件开发中经常遇到的一些设计问题，总结出来的一套通用的解决方案。
模板方法模式-封装一套算法流程
模板方法模式在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中，使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。
迭代器模式-统一集合的遍历方式
迭代器模式提供了一种方法，用于遍历集合对象中的元素，而又不暴露其内部的细节。
外观模式-简化子系统的复杂性
外观模式又叫门面模式，它提供了一个统一的（高层）接口，用来访问子系统中的一群接口，使得子系统更容易使用。
单例模式的五种实现方式及优缺点
单例模式（Singleton Design Pattern）保证一个类只能有一个实例，并提供一个全局访问点。
组合模式-统一的处理个别对象与组合对象
组合模式可以将对象组合成树形结构来表示“整体-部分”的层次结构，使得客户可以用一致的方式处理个别对象和对象组合。
装饰者模式-动态的包装原有对象的行为
装饰者模式能够更灵活的，动态的给对象添加其它功能，而不需要修改任何现有的底层代码。
观察者模式-将消息通知给观察者
观察者模式（Observer Design Pattern）定义了对象之间的一对多依赖，当对象状态改变的时候，所有依赖者都会自动收到通知。
代理模式-访问对象的代理而非其本身
代理模式为对象提供一个代理，来控制对该对象的访问。代理模式在不改变原始类代码的情况下，通过引入代理类来给原始类附加功能。
工厂模式-将对象的创建封装起来
工厂模式（Factory Design Pattern）可细分为三种，分别是简单工厂，工厂方法和抽象工厂，它们都是为了更好的创建对象。
状态模式-将状态和行为封装成对象
状态模式允许对象在内部状态改变时，改变它的行为，对象看起来好像改变了它的类。
命令模式-将请求封装成对象
命令模式将请求封装为对象，能够支持请求的排队执行、记录日志、撤销等功能。
【设计模式】备忘录模式
备忘录模式（Memento Pattern）保存一个对象的某个状态，以便在适当的时候恢复对象。备忘录模式属于行为型模式。 基本介绍 **意图：**在不破坏封装性的前提下，捕获一个对象的内部状态，并在该
【设计模式】职责链模式
顾名思义，责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为
【设计模式】享元模式
享元模式（Flyweight Pattern）（轻量级）（共享元素）主要用于减少创建对象的数量，以减少内存占用和提高性能。这种类型的设计模式属于结构型模式，它提供了减少对象数量从而改善应用所需的对象结
pythonJavaScriptjavaHTMLPHPreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-boot