//Subject java
目前累计服务客户上千余家，积累了丰富的产品开发及服务经验。以网站设计水平和技术实力，树立企业形象，为客户提供网站设计、成都网站设计、网站策划、网页设计、网络营销、VI设计、网站改版、漏洞修补等服务。创新互联建站始终以务实、诚信为根本，不断创新和提高建站品质，通过对领先技术的掌握、对创意设计的研究、对客户形象的视觉传递、对应用系统的结合，为客户提供更好的一站式互联网解决方案，携手广大客户，共同发展进步。
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
StockData（ extends Observable）只需要关注一个事件就好了。把多余的代码分割出来，封装到一个event事件类里。只要有新事件就通知 Investor( implements Observer)观察者有时间了。具体的时间有观察者调用时间的方法来触发。这样代码会整洁不少，逻辑也会很清晰、、
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类
