java中常见的模式之自定义观察者和java库中观察者

java定义了一种观察者接口对象，用于所有观察者类去实现它。也可以自定义的创建观察者接口，其中的原理都是差不多.

现在来简述第一种自定义观察者的原理：

1.首先建立一个观察者接口MyObserver.java，并写上抽象方法（当观察的目标改变了就会执行的更新操作），代码如下：

/**
 * 
 *这是观察者的抽象类，其他实体的观察者都要去实现它；
 */
public interface MyObserver { 
	/**
	 * 更新
	 * @param subject
	 */
	public void update(MySubject subject);
}

这里的update方法中传了 要观察的目标对象；

2.创建一个目标对象，作为所有观察者的目标对象，也是所有目标的父类；其中代码如下：

import java.util.ArrayList;
/**
 * 观察者的目标类
 * @author Administrator
 *
 */
public class MySubject {
    
    public ArrayList<MyObserver> mObservers = new ArrayList<MyObserver>();
    
    /**
     *添加观察者到 列表里，
     *代表了所有的观察该目标的观察者
     * @param obs
     */
    public void attach(MyObserver obs){
        mObservers.add(obs);
    }
    /**
     * 移除 在观察目标该列表里的观察对象
     * @param obs
     */
    public void datach(MyObserver obs){
        mObservers.remove(obs);
    }
    
    /**
     * 当目标值改变，就应该调用的方法
     * 这个方法是去刷新观察者列表里的每个观察者对象，这样观察者对象就会做出改变
     */
    public void notifyMyObserver(){
        for(int i=0;i<mObservers.size();i++){
            MyObserver observer = mObservers.get(i);
            observer.update(this);
        }
    }
}

就这样，自定义观察者中的基类就写完 了；

有了这两个基类，我们就可以做点示例的东西来诠释一下观察者模式的用处：

1.假设 两个对象，一个是学生Student.java ，一个是天气Weather.java  ,学生去观察天气的变化；

　天气作为目标，继承了目标基类，代码如下：

public class Weather extends MySubject {
    
    //天气的属性
    private String info;
    private String action;

    public String getInfo() {
        return info;
    }
    /**
     * @param info
     * @param action
     * 当set 来改变目标时。观察者就会得到刷新
     */
    public void setInfo(String info,String action) {
        this.info = info;
        this.action = action;
        notifyMyObserver();
    }
    public String getAction() {
        return action;
    }

    

}

解释一下，当天气的通过set方法来改变时，就会执行notifyMyobserver()方法，而观察者就会做出回应；

2，学生作为观察者来实现MyObserver接口，并实现该功能；代码如下：

/**
 * 学生是观察者之一，而学生 观察的目标 是 天气
 * 
 * @author Administrator
 *
 */
public class Student implements MyObserver {

    //增加学生的属性
    private String name;
    private String sex;
    private int age;
    
    public Student(String name,String sex){
        this.name = name;
        this.sex = sex;
    }
    /* (non-Javadoc)
     * @see MyObserver#update(MySubject)
     * 实现方法
     */
    @Override
    public void update(MySubject subject) {
        Weather weather = (Weather) subject;//将父类对象强制转换为 子类对象
        
        //获取到监督的目标对象的信息
        String info = weather.getInfo();
        String action = weather.getAction();
        //打印
            if(info.equals("下雨")){
                System.out.println("今天是:"+info+" "+name+"将要去"+action);
            }
        
    }

}

这里的关系有些绕，多看看就可以理解到位；

到这里自定义的观察者模式就演示完了

---

那么现在来看看简单的java库中的 观察者模式；

同样的原理，但是这里就不用去定义接口观测者，和目标基类，而是使用java库的；

先贴出，Weather.java目标类代码如下：

import java.util.Observable;
public class Weather extends Observable{
    private String info;
    private String wendu;
    public String getInfo() {
        return info;
    }
    public void setInfo(String info,String wendu) {
        this.info = info;
        this.wendu = wendu;
        setChanged();//改变了目标
        /*
         * 这里有两个方法，分别notifyObservers()，notifyObservers（org）有参数和无参数；有参数的刷新方法，就会传递
            对应的参数到  观察者的 update(Observable arg0, Object arg1)中的 org1，而无参的刷新方法中，传入的是整个目标对象arg0
        */
        notifyObservers();//java中定义的，就是继承了 目标观察者的方法，去刷新观察者
        //notifyObservers(wendu);
    }
    public String getWendu() {
        return wendu;
    }
}

那么，student.java观察者类代码：

import java.util.Observable;
import java.util.Observer;


/**
 * @author Administrator
 * 实现java中定义好的 观察者接口，其实现方法和自定义的类似
 *
 */
public class Student implements Observer {
    //增加学生的属性
    private String name;
    private String sex;
    private int age;
    
    public Student(String name,String sex){
        this.name = name;
        this.sex = sex;
    }
    
    /* (non-Javadoc)
     * @see java.util.Observer#update(java.util.Observable, java.lang.Object)
         这里的
     */
    @Override
    public void update(Observable arg0, Object arg1) {
        Weather w = (Weather) arg0;
        //获取到监督的目标对象的信息
        String info = w.getInfo();
        String action = w.getWendu();
        //打印
            if(info.equals("下雨")){
                System.out.println("今天是:"+info+" "+name+"将要去"+action);
            }
        
    }
        
        


}

在来个测试类代码，

/**
 * @author Administrator
 *这是个测试类
 */
public class main {
    public static void main(String args[]) {
        
        //写观察者的目标对象
        Weather w = new Weather();
        
        //两个学生的观察者
        Student st1 = new Student("小剑", "38");
        Student st2 = new Student("gooddog", "39");
        
        //用java中定义好的添加方法来吧目标 添加观察者对象（就是让这些观察者去观察它）
        w.addObserver(st2);
        w.addObserver(st1);
        
        //通过set来怪不数据，测试观察者数据是否会随着改变
        w.setInfo("下雨", "去网吧");
    }
}

嗯，到这里观察这模式就结束了，通过控制台打印就可以看到，改变了weather set方法的，就可打印出不同的值;

具体的就个人去测试吧；如果要源码就请留言。

”原创，转载请标注“