「java观察者模式例子」java观察者模式实例
今天给各位分享java观察者模式例子的知识,其中也会对java观察者模式实例进行解释,如果能碰巧解决你现在面临的问题,别忘了关注本站,现在开始吧!
本文目录一览:
- 1、Java中使用观察者模式实现自定义事件
- 2、java设计模式 观察者模式 代码
- 3、java 设计模式之 观察者模式(Observer)
- 4、Java程序性能优化-观察者模式(1)[1]
- 5、观察者模式(Observer)的推式与拉式
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观察者模式实例的介绍到此就结束了,不知道你从中找到你需要的信息了吗 ?如果你还想了解更多这方面的信息,记得收藏关注本站。
发布于:2023-01-20,除非注明,否则均为
原创文章,转载请注明出处。