总结学习观察者设计模式

基础定义

主题类：发布公告、通知的对象。也叫可观察者
观察者：被通知的对象。

拓展

在官方Jdk中，已经集成观察者模式的接口，观察者设计模式中还包括其他的设计模式思想：将同一个类中可能改变方法（鸭子的飞的方法）提取出来形成接口，再分别在不同类中（存在不同飞的类型的方法）实现这个方法，这时的这些类是超类，再用鸭子继承这个超类就有了飞的具体方法的类型，减少了代码的重写，提高复用。

通俗的理解

一些对象：
一个是发布通知的对象，如【报社】：他在更新数据的时候可以选择通告其他对象，并把需要告知其他对象的信息传递给他们。
其余是接受通知的对象，如【订阅报纸的人】：其他人得到这个信息后，自行选择处理方式。
他们形成一对多的关系。
上述过程抽象成代码实现过程是：

观察者模式代码实现

1. 观察者们（订阅者）实现官方的观察者接口Observer

public class ShowThree implements Observer{

2. 自动实现接口的方法，定制自己想要的实现，当可观察者发布通知时，即调用此方法，也是传递信息并处理信息的代码抽象，这里需要理解。

   @Override
   public void update(Observable o, Object arg) {
   	    if (o instanceof WeatherData) {
   	    	WeatherData wd = (WeatherData)o;
   	    	a = wd.getA();
   	    	b = wd.getB();
   	    	c = wd.getC();
   	    }
   	    //这是你自己的方法，可以添加形参，省略自己的属性
   		this.show();
   		}

3. 自定义构造方法

//新建对象时，用此构造方法，会自动注册给传入的可观察者，当他发布通知时，会通知到此对象
public ShowThree(Observable ob) {
		super();
		ob.addObserver(this);
	}

//可选择默认的，之后用可观察者对象手动注册这个对象，相当于你订阅报纸，给了钱，出版社就在他的发货栏列表里加上你的地址
	public ShowThree() {
		super();
	}

到此，观察者就建立好了

4. 官方有通用的观察者超类，我们自定义的观察者只需要继承这个超类就可以使用他的方法，有特殊需需求可以覆，添加自己的方法。
   5.官方超类（只贴了他的属性的方法）

java.util.Observable
java.util.Observable.changed
java.util.Observable.obs
java.util.Observable.Observable()
java.util.Observable.addObserver(Observer)
java.util.Observable.deleteObserver(Observer)
java.util.Observable.notifyObservers()
java.util.Observable.notifyObservers(Object)
java.util.Observable.deleteObservers()
java.util.Observable.setChanged()
java.util.Observable.clearChanged()
java.util.Observable.hasChanged()
java.util.Observable.countObservers()

5. 继承他，就有了他的方法（私有不会显示）

public class WeatherData extends Observable{

6. 重要的一步

//这是官方的通告方法，我们自定义的可观察中要通告直接调用这个方法就好了
 public void notifyObservers(Object arg) {
        Object[] arrLocal;
        synchronized (this) {
        //状态检查，默认是false
            if (!changed)
                return;
            arrLocal = obs.toArray();
            clearChanged();
        }
        for (int i = arrLocal.length-1; i>=0; i--)
            ((Observer)arrLocal[i]).update(this, arg);
    }

//但是需要变一下，官方的有状态检查，所以我们改为true，公告才能生效
//重写他的方法

	@Override
	public void notifyObservers() {
		// TODO Auto-generated method stub
		//将change字段值变为true，这里也可以自己设定变得条件，然后公告
		this.setChanged();
		super.notifyObservers();
	}

7. 测试

package test;

public class Main {
	
	public static void main(String[] args) {
	//实例化一个可观察者，并初始化一些需要传的数据
		WeatherData wd = new WeatherData(1, 2, 3);
//实例化一些观察者，自动注册给可观察者
		ShowOne so = new ShowOne(wd);
		ShowTwo st = new ShowTwo(wd);
		ShowThree sth = new ShowThree(wd);
//可观察者发布公告，所有观察者处理方法随即调用，消息就传递出去了
		wd.notifyObservers();
//没给钱的会员会被主动注销，不再给他公告，删除了关系。
		wd.deleteObserver(st);
		//再次公告就不存在了
		wd.notifyObservers();
		}
}

8. 结果

Three abc一起显示：乘123
Two abc一起显示：加减0
One abc一起显示：乘6
Three abc一起显示：乘123
One abc一起显示：乘6

9. 代码
   可观察者 ：一个

package test;

import java.util.Observable;

public class WeatherData extends Observable{

	private int a,b,c;


	public int getA() {
		return a;
	}

	public void setA(int a) {
		this.a = a;
	}

	public int getB() {
		return b;
	}

	public void setB(int b) {
		this.b = b;
	}

	public int getC() {
		return c;
	}

	public void setC(int c) {
		this.c = c;
	}

	public WeatherData(int a, int b, int c) {
		super();
		this.a = a;
		this.b = b;
		this.c = c;
	}

	public WeatherData() {
		super();
	}

	@Override
	public void notifyObservers() {
		// TODO Auto-generated method stub
		this.setChanged();
		super.notifyObservers();
	}

	@Override
	public void notifyObservers(Object arg) {
		// TODO Auto-generated method stub
		this.setChanged();
		super.notifyObservers(arg);
	}

}

观察者1：

package test;

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

public class ShowOne implements Observer,ShowType{
	
    int a,b,c;
	public ShowOne(Observable ob) {
		super();
		ob.addObserver(this);
	}


	@Override
	public void update(Observable o, Object arg) {
		    if (o instanceof WeatherData) {
		    	WeatherData wd = (WeatherData)o;
		    	a = wd.getA();
		    	b = wd.getB();
		    	c = wd.getC();
		    }
		
			this.show();
			
	}

	@Override
	public void show() {
		// TODO Auto-generated method stub
		System.out.println("One abc一起显示：乘"+a*b*c);
	}

}

观察者2：

package test;

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

public class ShowTwo implements Observer{

	int a,b,c;
	public ShowTwo(Observable ob) {
		super();
		ob.addObserver(this);
	}

    


	@Override
	public void update(Observable o, Object arg) {
		    if (o instanceof WeatherData) {
		    	WeatherData wd = (WeatherData)o;
		    	a = wd.getA();
		    	b = wd.getB();
		    	c = wd.getC();
		    }
		
			this.show();
			
	}

   protected void name() {
	
}
	
	public void show() {
		// TODO Auto-generated method stub
		System.out.println("Two abc一起显示：加减"+(a+b-c));
	}
}

观察者3：

package test;

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

public class ShowThree implements Observer{

	int a,b,c;
	public ShowThree(Observable ob) {
		super();
		ob.addObserver(this);
	}

	public ShowThree() {
		super();
	}

	@Override
	public void update(Observable o, Object arg) {
		    if (o instanceof WeatherData) {
		    	WeatherData wd = (WeatherData)o;
		    	a = wd.getA();
		    	b = wd.getB();
		    	c = wd.getC();
		    }
		
			this.show();
			
	}

	public void show() {
		// TODO Auto-generated method stub
		System.out.println("Three abc一起显示：乘"+a+b+c);
	}
}