观察者模式java代码 java 观察者模式 流程审批
JAVA观察者模式(observer pattern)
import java.util.ArrayList;
成都创新互联从2013年创立，是专业互联网技术服务公司，拥有项目成都做网站、网站设计网站策划，项目实施与项目整合能力。我们以让每一个梦想脱颖而出为使命，1280元普兰做网站,已为上家服务,为普兰各地企业和个人服务,联系电话:18980820575
import java.util.HashMap;
import java.util.Random;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
public class StockLists implements Runnable
{
private HashMapString, Stock hmStocks = new HashMapString, Stock();
private HashMapString, ArrayListChangeListener hmCL = new HashMapString, ArrayListChangeListener();
public StockLists()
{
init(100);
new Thread(this).start();
}
public void run()
{
Random rand = new Random();
while (true)
{
try
{
Thread.sleep(100);
Stock s = randStock();
s.price = rand.nextFloat();
ArrayListChangeListener alCL = hmCL.get(s.symbol);
if (alCL == null)
{
continue;
}
for (ChangeListener cl : alCL)
{
cl.stateChanged(new ChangeEvent(s));
}
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
}
private Stock randStock()
{
Random rand = new Random();
int idx = rand.nextInt(hmStocks.size());
String sym = (String) hmStocks.keySet().toArray()[idx];
Stock s = hmStocks.get(sym);
return s;
}
public boolean addChangeListener(ChangeListener cl, String sym)
{
ArrayListChangeListener al = hmCL.get(sym);
if (al == null)
{
al = new ArrayListChangeListener();
hmCL.put(sym, al);
}
return al.add(cl);
}
private void init(int count)
{
Random rand = new Random();
for (int i = 0; i count; i++)
{
String sym = randSym(rand);
float p = rand.nextFloat();
Stock s = new Stock(sym, p);
hmStocks.put(sym, s);
}
}
private String randSym(Random rand)
{
char[] ca = new char[3];
for (int i = 0; i ca.length; i++)
{
ca[i] = (char) ('A' + rand.nextInt(26));
}
return new String(ca);
}
public static void main(String[] args)
{
StockLists sl = new StockLists();
sl.addChangeListener(new Investor("111"), sl.randStock().symbol);
sl.addChangeListener(new Investor("222"), sl.randStock().symbol);
sl.addChangeListener(new Investor("333"), sl.randStock().symbol);
sl.addChangeListener(new Investor("444"), sl.randStock().symbol);
sl.addChangeListener(new Investor("555"), sl.randStock().symbol);
sl.addChangeListener(new Investor("666"), sl.randStock().symbol);
sl.addChangeListener(new Investor("777"), sl.randStock().symbol);
sl.addChangeListener(new Investor("888"), sl.randStock().symbol);
sl.addChangeListener(new Investor("999"), sl.randStock().symbol);
sl.addChangeListener(new Investor("000"), sl.randStock().symbol);
}
}
class Stock
{
public String symbol = null;
public float price = 0.0f;
public Stock(String sym, float p)
{
symbol = sym;
price = p;
}
public String toString()
{
return symbol + ":" + price;
}
}
class Investor implements ChangeListener
{
public String name = "";
public Investor(String name)
{
this.name = name;
}
@Override
public void stateChanged(ChangeEvent e)
{
Stock s = (Stock) e.getSource();
System.out.println("Hello," + name + " : STOCK CHANGED: " + s);
}
}
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中使用观察者模式实现自定义事件
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代码 java 观察者模式 流程审批
浏览路径：http://ybzwz.com/article/dosecic.html
