「java观察者模式例子」java观察者模式实例

博主:adminadmin 2023-01-20 08:09:08 73

今天给各位分享java观察者模式例子的知识,其中也会对java观察者模式实例进行解释,如果能碰巧解决你现在面临的问题,别忘了关注本站,现在开始吧!

本文目录一览:

Java中使用观察者模式实现自定义事件

MyEventTest java:

package wintys event;

import javax swing event EventListenerList;

import java util Date;

import java text DateFormat;

import java text SimpleDateFormat;

/**

* Java的事件机制/自定义事件

运行结果:

do something interesting in source here

listener detects [event]:wintys event MyEvent[source=wintys event MySource@

] [occur at]: : :

listener detects [event]:wintys event MyEvent[source=wintys event MySource@

] [occur at]: : :

* @version

* @author 天堂露珠 ()

* @see

*/

class MyEventTest{

public static void main(String[] args){

MySource source = new MySource();

MyListener myListener = new MyListener(){

public void doMyAction(MyEvent e){

System out println( listener detects + e);

}

};

source addMyListener(myListener);

source addMyListener(myListener);

source addMyListener(myListener);

source removeMyListener(myListener);

source doSomething();

}

}

/**

* 自定义的事件

* @version

* @author 天堂露珠()

* @see

*/

class MyEvent extends java util EventObject{

private Date date;//记录事件发生的时间

public MyEvent(Object source Date date){

super(source);

this date = date;

}

public String toString(){

DateFormat df = new SimpleDateFormat( yyyy MM dd HH:mm:ss );

String dt = df format(date);

return [event]: + super toString() + [occur at]: + dt;

}

}

/**

* 自定义事件监听器接口

* @version

* @author 天堂露珠()

* @see

*/

interface MyListener extends java util EventListener{

void doMyAction(MyEvent e);

}

/**

* 自定义事件源

* @version

* @author 天堂露珠()

* @see

*/

class MySource{

/**

* 保存注册的监听器列表

* 子类可以使用它保存自己的事件监听器(非MyListener监听器)列表

*/

protected EventListenerList listenerList = new EventListenerList();

private MyEvent myEvent = null;//fireDoMyAction()使用此变量

/**

* 没有做任何事

*/

public MySource(){

}

/**

* 添加一个MyListener监听器

*/

public void addMyListener(MyListener listener){

listenerList add(MyListener class listener);

}

/**

* 移除一个已注册的MyListener监听器

* 如果监听器列表中已有相同的监听器listener listener

* 并且listener ==listener

* 那么只移除最近注册的一个监听器

*/

public void removeMyListener(MyListener listener){

listenerList remove(MyListener class listener);

}

/**

* @return 在此对象上监听的所有MyListener类型的监听器

*/

public MyListener[] getMyListeners(){

return (MyListener[])listenerList getListeners(MyListener class);

}

//Winty:Copy directly from javax swing event EventListenerList

/*Notify all listeners that have registered interest for

notification on this event type The event instance

is lazily created using the parameters passed into

the fire method

*/

protected void fireDoMyAction() {

// getListenerList() Guaranteed to return a non null array

Object[] listeners = listenerList getListenerList();

// Process the listeners last to first notifying

// those that are interested in this event

for (int i = listeners length ; i= ; i = ) {

if (listeners[i]==MyListener class) {

// Lazily create the event:

if (myEvent == null)

myEvent = new MyEvent(this new Date());

((MyListener)listeners[i+ ]) doMyAction(myEvent);

}

}

}

/**

* 做一些事件源应该做的有意义的事 然后通知监听器

* 这里只是一个示例方法

* 例如:MySource如果是一个按钮 则doSomething()就可以命名为click()

* 当用户点击按钮时调用click()方法

*/

public void doSomething() {

System out println( do something interesting here );

fireDoMyAction();//通知监听器

}

}

lishixinzhi/Article/program/Java/hx/201311/26237

java设计模式 观察者模式 代码

第一个

public interface RandomNumberListener {//接口

public void numberChanged(double d);

}

第二个

public class Consol implements RandomNumberListener{

@Override

public void numberChanged(double d) {

System.out.println(d);

}

}

第三个

public class SwingWindow

extends JFrame

implements RandomNumberListener{//观察者

private JLabel label = new JLabel();

public SwingWindow(){

this.getContentPane().add( label);

this.setSize(300,200);

this.setVisible(true);

}

@Override

public void numberChanged(double d) {

label.setText(String.valueOf(d));

}

}

第四个

public class RandomNumber {//业务

private double r;

private ListRandomNumberListener listeners = new ArrayListRandomNumberListener();

//添加所有观察者

public void addRandomNumberListener(RandomNumberListener lis){

listeners.add(lis);

}

public void random(){

r = Math.random();

//数据发生改变,通知所有的观察者

for (RandomNumberListener lis : listeners) {

lis.numberChanged(r);

}

}

}

第五个

public class Test {

public static void main(String[] args) throws InterruptedException{

RandomNumber rn = new RandomNumber();

SwingWindow sw = new SwingWindow();

Consol c = new Consol();

rn.addRandomNumberListener(sw);

rn.addRandomNumberListener(c);

while(true){

rn.random();

Thread.sleep(new Random().nextInt(3000)+1000L);

}

}

}

java 设计模式之 观察者模式(Observer)

//Subject java

package youngmaster model Observer;

/**

* @author youngmaster

* @E mail:young * @version myEclipse

* @create time 上午 : :

*/

/**

* 察者模式属于行为型模式 其意图是定义对象间的一种一对多的依赖关系

* 当一个对象的状态发生改变时 所有依赖于它的对象都得到通知并被自动更新

* 在制作系统的过程中 将一个系统分割成一系列相互协作的类有一个常见的副作用

* 需要维护相关对象间的一致性 我们不希望为了维持一致性而使各类紧密耦合

* 因为这样降低了他们的可充用性 这一个模式的关键对象是目标(Subject)和观察者(Observer)

* 一个目标可以有任意数目的依赖它的观察者 一旦目标的状态发生改变 所有的观察者都得到通知

* 作为对这个通知的响应 每个观察者都将查询目标以使其状态与目标的状态同步 这种交互也称为发布 订阅模式

* 目标是通知的发布者 他发出通知时并不需要知道谁是他的观察者 可以有任意数据的观察者订阅并接收通知

*/

/**

* subject

*目标接口

*/

public interface Subject {

public void addObserver(Observer o);

public void deletObserver(Observer o);

public void notice();

}

//Observer java

package youngmaster model Observer;

/**

* @author youngmaster

* @E mail:young * @version myEclipse

* @create time 上午 : :

*/

/**

*观察者接口

*/

public interface Observer {

public void update();

}

//Teacher java

package youngmaster model Observer;

import java util Vector;

/**

* @author youngmaster

* @E mail:young * @version myEclipse

* @create time 上午 : :

*/

/**

*目标接口实现

*/

public class Teacher implements Subject {

private String phone;

@SuppressWarnings( unchecked )

private Vector students;

@SuppressWarnings( unchecked )

public Teacher() {

phone = ;

students = new Vector();

}

@SuppressWarnings( unchecked )

@Override

public void addObserver(Observer o) {

students add(o);

}

@Override

public void deletObserver(Observer o) {

students remove(o);

}

@Override

public void notice() {

for (int i = ; i students size(); i++) { ((Observer) students get(i)) update();

}

}

public void setPhone(String phone) {

this phone = phone;

notice();

}

public String getPhone() {

return phone;

}

}

//Student java

package youngmaster model Observer;

/**

* @author youngmaster

* @E mail:young * @version myEclipse

* @create time 上午 : :

*/

/**

*观察者接口实现

*/

public class Student implements Observer {

private String name;

private String phone;

private Teacher teacher;

public Student(String name Teacher teacher) { this name = name; this teacher = teacher;

}

public void show() {

System out println( Name: + name + \nTeacher s phone: + phone);

}

@Override

public void update() {

phone = teacher getPhone();

}

}

//Client java

package youngmaster model Observer;

import java util Vector;

/**

* @author youngmaster

* @E mail:young * @version myEclipse

* @create time 上午 : :

*/

/**

*测试类

*/

public class Client {

/**

* @param args

*/

@SuppressWarnings( unchecked )

public static void main(String[] args) {

Vector students = new Vector();

Teacher teacher = new Teacher();

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

Student student = new Student( student + i teacher); students add(student); teacher addObserver(student);

}

teacher setPhone( );

for (int i = ; i ; i++)

((Student) students get(i)) show();

System out println( \n============================\n );

teacher setPhone( );

for (int i = ; i ; i++)

((Student) students get(i)) show();

}

lishixinzhi/Article/program/Java/gj/201311/27566

Java程序性能优化-观察者模式(1)[1]

  观察者模式( )

观察者模式是非常常用的一种设计模式 在软件系统中 当一个对象的行为依赖于另一个对象的状态时 观察者模式就相当有用 若不使用观察者模式提供的通用结构 而需要实现其类似的功能 则只能在另一个线程中不停监听对象所依赖的状态 在一个复杂系统中 可能会因此开启很多线程来实现这一功能 这将使系统的性能产生额外的负担 观察者模式的意义也就在此 它可以在单线程中 使某一对象 及时得知自身所依赖的状态的变化 观察者模式的经典结构如图 所示

图   观察者模式结构

ISubject是被观察对象 它可以增加或者删除观察者 IOberver是观察者 它依赖于ISubject的状态变化 当ISubject状态发生改变时 会通过inform()方法通知观察者

注意 观察者模式可以用于事件监听 通知发布等场合 可以确保观察者在不使用轮询监控的情况下 及时收到相关消息和事件

观察者模式的主要角色如表 所示

表   观察者模式角色

主题接口的实现如下

lishixinzhi/Article/program/Java/gj/201311/27819

观察者模式(Observer)的推式与拉式

当我们想订一份报纸,我们先去邮局找到报纸的编号后填写订阅单并缴费。当报社有新报纸发出时,邮局会将我们订阅的报纸发给我们。

为了简单我们去掉邮局环节简化成:报社有新报纸后马上通知用户,这就是观察者。

定义对象间的一对多关系,当一个对象的状态发生变化时,所依赖于它的对象都得到通知并主动更新。 在观察者模式中,多个订阅者成为观察者(Observer),被观察的对象成为目标(Subject)。观察者的UML模型如下:

先定义Subject并写一个ConcreteSubject继承Subject:

再定义一个接口Observer,并写一个ConcreteObserver实现Observer接口:

最后看看主函数方法:

打印出来的结果:

在实现观察者模式的时候,一定要注意触发通知的时机。一般情况下是在完成了状态改变之后触发,因为通知会传递数据,比如在 setSubjectState 时先通知观测者就会发生 错误 。

在观察者模式的实现上,有推模式和拉模式两种方式:

当前上面的实现使用的就是拉模型。通过 (ConcreteSubject)subject 得到具体对象,获得信息。

当然Java本身就有观察者模式的部分实现,分别是 java.util.Observable java.util.Observable 。

下面看一个使用Java自带观察者模式的例子:

新的目标直接继承Java中定义的Observerable:

新的观察者也直接实现Observer接口:

主函数和前面的相似:

打印出结果:

使用Java自带的观察者模式需要注意以下几个问题:

关于java观察者模式例子和java观察者模式实例的介绍到此就结束了,不知道你从中找到你需要的信息了吗 ?如果你还想了解更多这方面的信息,记得收藏关注本站。

The End

发布于:2023-01-20,除非注明,否则均为首码项目网原创文章,转载请注明出处。