您的位置:

java观察者模式,我的世界java观察者模式

本文目录一览:

java中常用到得设计模式有哪几种?

一共23种设计模式!

按照目的来分,设计模式可以分为创建型模式、结构型模式和行为型模式。

创建型模式用来处理对象的创建过程;结构型模式用来处理类或者对象的组合;行为型模式用来对类或对象怎样交互和怎样分配职责进行描述。

创建型模式用来处理对象的创建过程,主要包含以下5种设计模式:

 工厂方法模式(Factory Method Pattern)

 抽象工厂模式(Abstract Factory Pattern)

 建造者模式(Builder Pattern)

 原型模式(Prototype Pattern)

 单例模式(Singleton Pattern)

结构型模式用来处理类或者对象的组合,主要包含以下7种设计模式:

 适配器模式(Adapter Pattern)

 桥接模式(Bridge Pattern)

 组合模式(Composite Pattern)

 装饰者模式(Decorator Pattern)

 外观模式(Facade Pattern)

 享元模式(Flyweight Pattern)

 代理模式(Proxy Pattern)

行为型模式用来对类或对象怎样交互和怎样分配职责进行描述,主要包含以下11种设计模式:

 责任链模式(Chain of Responsibility Pattern)

 命令模式(Command Pattern)

 解释器模式(Interpreter Pattern)

 迭代器模式(Iterator Pattern)

 中介者模式(Mediator Pattern)

 备忘录模式(Memento Pattern)

 观察者模式(Observer Pattern)

 状态模式(State Pattern)

 策略模式(Strategy Pattern)

 模板方法模式(Template Method Pattern)

 访问者模式(Visitor Pattern)

推荐你一本好书:《软件秘笈:设计模式那点事》,里面讲解的23中设计模式例子很生动,容易理解,还有JDK中设计模式应用情况,看了收获挺大的!百度里面搜“设计模式”,第一条中设计模式百度百科中就有首推该图书,浏览量在20几万以上的,不会错的。好东西大家一起分享!

祝你早日学会设计模式!

java设计模式-回调、事件监听器、观察者模式

转自( )

背景

关于设计模式,之前笔者写过工厂模式,最近在使用gava ListenableFuture时发现事件监听模型特别有意思,于是就把事件监听、观察者之间比较了一番,发现这是一个非常重要的设计模式,在很多框架里扮演关键的作用。

回调函数

为什么首先会讲回调函数呢?因为这个是理解监听器、观察者模式的关键。

什么是回调函数

所谓的回调,用于回调的函数。 回调函数只是一个功能片段,由用户按照回调函数调用约定来实现的一个函数。 有这么一句通俗的定义:就是程序员A写了一段程序(程序a),其中预留有回调函数接口,并封装好了该程序。程序员B要让a调用自己的程序b中的一个方法,于是,他通过a中的接口回调自己b中的方法。

举个例子:

这里有两个实体:回调抽象接口、回调者(即程序a)

回调接口(ICallBack )

public interface ICallBack {

public void callBack();

}

回调者(用于调用回调函数的类)

public class Caller {

}

回调测试:

public static void main(String[] args) {

Caller call = new Caller();

call.call(new ICallBack(){

控制台输出:

start...

终于回调成功了!

end...

还有一种写法

或实现这个ICallBack接口类

class CallBackC implements ICallBack{

@Override

public void callBack() {

System.out.println("终于回调成功了!");

}

}

有没有发现这个模型和执行一个线程,Thread很像。 没错,Thread就是回调者,Runnable就是一个回调接口。

new Thread(new Runnable(){

@Override

public void run() {

System.out.println("回调一个新线程!");

}}).start();

Callable也是一个回调接口,原来一直在用。 接下来我们开始讲事件监听器

事件监听模式

什么是事件监听器

监听器将监听自己感兴趣的事件一旦该事件被触发或改变,立即得到通知,做出响应。例如:android程序中的Button事件。

java的事件监听机制可概括为3点:

java的事件监听机制涉及到 事件源,事件监听器,事件对象 三个组件,监听器一般是接口,用来约定调用方式

当事件源对象上发生操作时,它将会调用事件监听器的一个方法,并在调用该方法时传递事件对象过去

事件监听器实现类,通常是由开发人员编写,开发人员通过事件对象拿到事件源,从而对事件源上的操作进行处理

举个例子

这里我为了方便,直接使用jdk,EventListener 监听器,感兴趣的可以去研究下源码,非常简单。

监听器接口

public interface EventListener extends java.util.EventListener {

//事件处理

public void handleEvent(EventObject event);

}

事件对象

public class EventObject extends java.util.EventObject{

private static final long serialVersionUID = 1L;

public EventObject(Object source){

super(source);

}

public void doEvent(){

System.out.println("通知一个事件源 source :"+ this.getSource());

}

}

事件源

事件源是事件对象的入口,包含监听器的注册、撤销、通知

public class EventSource {

//监听器列表,监听器的注册则加入此列表

private VectorEventListener ListenerList = new VectorEventListener();

//注册监听器

public void addListener(EventListener eventListener){

ListenerList.add(eventListener);

}

//撤销注册

public void removeListener(EventListener eventListener){

ListenerList.remove(eventListener);

}

//接受外部事件

public void notifyListenerEvents(EventObject event){

for(EventListener eventListener:ListenerList){

eventListener.handleEvent(event);

}

}

}

测试执行

public static void main(String[] args) {

EventSource eventSource = new EventSource();

}

控制台显示:

通知一个事件源 source :openWindows

通知一个事件源 source :openWindows

doOpen something...

到这里你应该非常清楚的了解,什么是事件监听器模式了吧。 那么哪里是回调接口,哪里是回调者,对!EventListener是一个回调接口类,handleEvent是一个回调函数接口,通过回调模型,EventSource 事件源便可回调具体监听器动作。

有了了解后,这里还可以做一些变动。 对特定的事件提供特定的关注方法和事件触发

public class EventSource {

...

public void onCloseWindows(EventListener eventListener){

System.out.println("关注关闭窗口事件");

ListenerList.add(eventListener);

}

}

public static void main(String[] args) {

EventSource windows = new EventSource();

/**

* 另一种实现方式

*/

//关注关闭事件,实现回调接口

windows.onCloseWindows(new EventListener(){

}

这种就类似于,我们的窗口程序,Button监听器了。我们还可以为单击、双击事件定制监听器。

观察者模式

什么是观察者模式

观察者模式其实原理和监听器是一样的,使用的关键在搞清楚什么是观察者、什么是被观察者。

观察者(Observer)相当于事件监器。有个微博模型比较好理解,A用户关注B用户,则A是B的观察者,B是一个被观察者,一旦B发表任何言论,A便可以获得。

被观察者(Observable)相当于事件源和事件,执行事件源通知逻辑时,将会回调observer的回调方法update。

举个例子

为了方便,同样我直接使用jdk自带的Observer。

一个观察者

public class WatcherDemo implements Observer {

@Override

public void update(Observable o, Object arg) {

if(arg.toString().equals("openWindows")){

System.out.println("已经打开窗口");

}

}

}

被观察者

Observable 是jdk自带的被观察者,具体可以自行看源码和之前的监听器事件源类似。

主要方法有

addObserver() 添加观察者,与监听器模式类似

notifyObservers() 通知所有观察者

类Watched.java的实现描述:被观察者,相当于事件监听的事件源和事件对象。又理解为订阅的对象 主要职责:注册/撤销观察者(监听器),接收主题对象(事件对象)传递给观察者(监听器),具体由感兴趣的观察者(监听器)执行

/**

}

测试执行

public static void main(String[] args) {

Watched watched = new Watched();

WatcherDemo watcherDemo = new WatcherDemo();

watched.addObserver(watcherDemo);

watched.addObserver(new Observer(){

@Override

public void update(Observable o, Object arg) {

if(arg.toString().equals("closeWindows")){

System.out.println("已经关闭窗口");

}

}

});

//触发打开窗口事件,通知观察者

watched.notifyObservers("openWindows");

//触发关闭窗口事件,通知观察者

watched.notifyObservers("closeWindows");

控制台输出:

已经打开窗口

已经关闭窗口

总结

从整个实现和调用过程来看,观察者和监听器模式基本一样。

有兴趣的你可以基于这个模型,实现一个简单微博加关注和取消的功能。 说到底,就是事件驱动模型,将调用者和被调用者通过一个链表、回调函数来解耦掉,相互独立。

“你别来找我,有了我会找你”。

整个设计模式的初衷也就是要做到低耦合,低依赖。

再延伸下,消息中间件是什么一个模型? 将生产者+服务中心(事件源)和消费者(监听器)通过消息队列解耦掉. 消息这相当于具体的事件对象,只是存储在一个队列里(有消峰填谷的作用),服务中心回调消费者接口通过拉或取的模型响应。 想必基于这个模型,实现一个简单的消息中间件也是可以的。

还比如gava ListenableFuture,采用监听器模式就解决了future.get()一直阻塞等待返回结果的问题。

有兴趣的同学,可以再思考下观察者和责任链之间的关系, 我是这样看的。

同样会存在一个链表,被观察者会通知所有观察者,观察者自行处理,观察者之间互不影响。 而责任链,讲究的是击鼓传花,也就是每一个节点只需记录继任节点,由当前节点决定是否往下传。 常用于工作流,过滤器web filter。

java设计模式的两大主题是什么,

设计模式的两大主题是系统复用与系统扩展。Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等。

扩展资料

由四方面组成:

(1)Java编程语言

(2)Java类文件格式

(3)Java虚拟机

(4)Java应用程序接口

当编辑并运行一个Java程序时,需要同时涉及到这四种方面。使用文字编辑软件(例如记事本、写字板、UltraEdit等)或集成开发环境(Eclipse、MyEclipse等)在Java源文件中定义不同的类 ,通过调用类(这些类实现了Java API)中的方法来访问资源系统,把源文件编译生成一种二进制中间码,。

存储在class文件中,然后再通过运行与操作系统平台环境相对应的Java虚拟机来运行class文件,执行编译产生的字节码,调用class文件中实现的方法来满足程序的Java API调用。

Java的回调函数和观察者模式的区别

java的回调 叫listener 模式。

无论是listener模式,还是C++里面的callback模式,本质是一样的

他们都是观察者模式的具体实现。

观察者模式是设计模式中定义的一种思想,而具体到不同的语言环境,使用不同的语法表现出来就会有java的listener objc的 delegate,或者C++的 callback。

观察者模式解析

定义 :对象间的一种一对多的依赖关系,使得当每一个对象改变状态,则所有依赖于他的对象都会得到通知,并自动更新。

交互对象之间松耦合

1)观察者定义了对象之间一对多的关系

2)被观察者用一个共同的接口来更新观察者

3)观察者和被观察者用松耦合方式结合,被观察者不知道观察者的细节,只知道观察者实现了观察者接口

优点:

1)观察者与被观察者抽象耦合,容易扩展;

2)建立了一套触发机制。

缺点:

1)循环依赖会导致系统崩溃;

2)观察者太多会浪费时间。

1)定义对象之间的一对多依赖关系而不使对象紧密耦合。

2)确保当一个对象改变状态时,自动更新开放数量的从属对象。

3)一个对象应该可以通知开放式数量的其他对象。

观察者模式 vs 发布-订阅模式

观察者模式(Observer)

如何使用 Java8 实现观察者模式?(上)

如何使用 Java8 实现观察者模式?(下)

求 JAVA 异步观察者模式 的源代码(完整的),不要同步的,好的给加分

package TestObserver;

import java.util.Iterator;

import java.util.Vector;

/**

*

* @author Seastar

*/

interface Observed {

public void addObserver(Observer o);

public void removeObserver(Observer o);

public void update();

}

interface Observer {

public void takeAction();

}

class Invoker {

private Observer o;

Handler handler;

public Invoker(Observer o) {

new Handler();

this.o = o;

}

private class Handler extends Thread {

public Handler() {

handler = this;

}

@Override

public void run() {

o.takeAction();

}

}

public boolean TestSameObserver(Observer o) {

return o == this.o;

}

public void invoke() {

handler.start();

}

}

class ObservedObject implements Observed {

private VectorInvoker observerList = new VectorInvoker();

public void addObserver(Observer o) {

observerList.add(new Invoker(o));

}

public void removeObserver(Observer o) {

IteratorInvoker it = observerList.iterator();

while (it.hasNext()) {

Invoker i = it.next();

if (i.TestSameObserver(o)) {

observerList.remove(i);

break;

}

}

}

public void update() {

for (Invoker i : observerList) {

i.invoke();

}

}

}

class ObserverA implements Observer {

public void takeAction() {

System.out.println("I am Observer A ,state changed ,so i have to do something");

}

}

class ObserverB implements Observer {

public void takeAction() {

System.out.println("I am Observer B ,i was told to do something");

}

}

class ObserverC implements Observer {

public void takeAction() {

System.out.println("I am Observer C ,I just look ,and do nothing");

}

}

public class Main {

/**

* @param args the command line arguments

*/

public static void main(String[] args) {

ObserverA a = new ObserverA();

ObserverB b = new ObserverB();

ObserverC c = new ObserverC();

ObservedObject oo = new ObservedObject();

oo.addObserver(a);

oo.addObserver(b);

oo.addObserver(c);

for (int i = 0; i 5; ++i) {

oo.addObserver(new Observer() {

public void takeAction() {

System.out.println("我是山寨观察者"+",谁敢拦我");

}

});

}

//sometime oo changed ,so it calls update and informs all observer

oo.update();

}

}

观察者模式的精髓在于注册一个观察者观测可能随时变化的对象,对象变化时就会自动通知观察者,

这样在被观测对象影响范围广,可能引起多个类的行为改变时很好用,因为无需修改被观测对象的代码就可以增加被观测对象影响的类,这样的设计模式使得代码易于管理和维护,并且减少了出错几率

至于异步机制实际是个噱头,可以有观测对象来实现异步,也可以有观察者自身实现,这个程序实际是观测对象实现了异步机制,方法是在观察者类外包装了一层invoker类

java观察者模式,我的世界java观察者模式

2023-01-09
观察者模式java,观察者模式java代码

2022-11-27
java观察者模式,java观察者模式与消息队列

2023-01-07
java观察者,java观察者模式监控线程

2022-11-30
Java观察者模式详解

2023-05-22
观察者模式Java详解

2023-05-18
Java观察者模式的应用与解析

2023-05-19
JS观察者模式

2023-05-17
JavaObservable:使用观察者模式实现事件监听

2023-05-22
C#观察者模式详解

2023-05-20
Android观察者模式的详解

2023-05-21
深入浅出:观察者设计模式

2023-05-22
Android中使用观察者模式实现数据更新实时通知

一、什么是观察者模式? 观察者模式(Observer Pattern)是一种设计模式,用于当一个对象的状态发生变化时,所有依赖于它的对象都会得到通知并自动更新。该模式也称作发布-订阅模式(Publis

2023-12-08
如何为Android建立可观察的模式

在Android应用开发中,使用可观察的模式(Observable Pattern)可以帮助我们更好地管理应用程序中的数据,并且在视图更新时也非常有用。在本文中,我们将讨论如何为Android应用程序

2023-12-08
java建造者模式应用场景,设计者模式java

2022-11-20
我们的设计模式java设计模式,java中的设计模式

2022-11-23
java模式,java模式有哪些

2023-01-09
用法介绍Java Observer模式

JavaObserver是一种设计模式,它定义了对象之间的一对多依赖,当对象改变状态时,它会自动通知和更新的所有依赖。一、Java Observer模式基础1、Observer模式主要用于实现分布式系

2023-12-08
java构造者模式用在哪(java构造者模式用在哪些地方)

2022-11-16
java的设计模式,Java的设计模式共有多少种

2023-01-09