观察者模式(Observer) Java，观察者observer

观察者模式(Observer) Java，观察者observer

定义

 观察者模式(Observer 发布-订阅):定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

类图

代码

Observer订阅者抽象类

package ding.study.designpatterns.observer;

/**
 * 订阅者抽象类
 * 
 * @author daniel
 * 
 */
public abstract class Observer {
	/**
	 * 订阅者更新发布者发布的内容
	 */
	public abstract void update();
}

订阅者实现类ObserverConcrete

package ding.study.designpatterns.observer;

/**
 * 订阅者实现类
 * 
 * @author daniel
 * 
 */
public class ObserverConcrete extends Observer {
	private double agPrice;
	private String name;
	private SubjectConcrete subjectConcrete;// 发布者实现类

	/**
	 * 出入 发布者 和 自己的私有信息
	 * 
	 * @param subjectConcrete
	 * @param name
	 */
	public ObserverConcrete(SubjectConcrete subjectConcrete, String name) {
		this.subjectConcrete = subjectConcrete;
		this.name = name;
	}

	/**
	 * 获得发布者 的最新数据
	 */
	@Override
	public void update() {
		agPrice = subjectConcrete.getAgPrice();
		System.out.println("观察者" + name + " 观察到 最新价格是 " + agPrice);
	}

}

Subject发布者抽象类

package ding.study.designpatterns.observer;
import java.util.ArrayList;
import java.util.List;
/**
 * 发布者抽象类
 * @author daniel
 *
 */
abstract class Subject {
      //订阅者列表
 private List<Observer> observers=new ArrayList<Observer>();
 /**
  * 添加订阅者
  * @param observer
  */
 public void addObserver(Observer observer){
  observers.add(observer);
 }
 /**
  * 删除订阅者
  * @param observer
  */
 public void deleteObserver(Observer observer){
  observers.remove(observer);
 }
 /**
  * 发布给所有订阅者
  */
 public void Notify(){
  for(Observer observer : observers){
   observer.update();
  }  
 } 
}

SubjectConcrete发布者子类 加入发布的具体内容 白银价格

package ding.study.designpatterns.observer;

/**
 * 发布者子类 加入发布的具体内容 白银价格
 * 
 * @author daniel
 * 
 */
public class SubjectConcrete extends Subject {
	// 白银价格
	private double agPrice;

	/**
	 * @return the agPrice
	 */
	public double getAgPrice() {
		return agPrice;
	}

	/**
	 * @param agPrice
	 *            the agPrice to set
	 */
	public void setAgPrice(double agPrice) {
		this.agPrice = agPrice;
		this.Notify();
	}

}

测试类

package ding.study.designpatterns.observer;

import java.util.Scanner;
/**
 * 观察者模式(发布-订阅):定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。
 * 
 * 
 * @author daniel
 * @email 576699909@qq.com
 * @time 2016-6-18 下午4:01:40
 */
public class Zmain {

	/**
	 * @author daniel
	 * @time 2016-6-18 下午3:57:10
	 * @param args
	 */
	public static void main(String[] args) {
		// 创建发布者
		SubjectConcrete subjectConcrete = new SubjectConcrete();
		// 加入 订阅者
		subjectConcrete.addObserver(new ObserverConcrete(subjectConcrete, "狼"));
		subjectConcrete.addObserver(new ObserverConcrete(subjectConcrete, "林"));
		subjectConcrete.addObserver(new ObserverConcrete(subjectConcrete, "rod johnson"));
		// 发布者更新发布信息 并且发给订阅者
		subjectConcrete.setAgPrice(10);
		// subjectConcrete.Notify();
		while (true) {
			System.out.println("\n\n请输入就最新价格：");
			Scanner scanner = new Scanner(System.in);
			String str = scanner.nextLine();
			if (str.equals("exit")) {
				System.out.println("结束");
				break;
			}
			System.out.println("您输入的价格为:" + str);
			subjectConcrete.setAgPrice(Double.valueOf(str));
		}

	}

}

输出

观察者狼 观察到 最新价格是 10.0
观察者林 观察到 最新价格是 10.0
观察者rod johnson 观察到 最新价格是 10.0


请输入就最新价格：
9
您输入的价格为:9
观察者狼 观察到 最新价格是 9.0
观察者林 观察到 最新价格是 9.0
观察者rod johnson 观察到 最新价格是 9.0

JDK自带实现类

 java.util .Observable  Observable 也提供了实现 观察者模式的接口（发布-订阅）

package ding.study.designpatterns.observer;

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

public class AgObserver implements Observer {
	private String name;

	public AgObserver(String name) {
		this.name = name;
	}

	public void update(Observable arg0, Object arg1) {
		if (arg1 instanceof Double) {
			System.out.println(this.name + "观察到的价格更改为\n" + ((Double) arg1).toString());
		}

	}

}




package ding.study.designpatterns.observer;

import java.util.Observable;
/**
 * 白银价格类
 * @author daniel
 *
 */
public class AgPrice extends Observable {
  
   private double price;
   public AgPrice(double price){
    this.price=price;    
   }
   
   public void setPrice(double price){
       super.setChanged();
        super.notifyObservers(price);
    this.price=price;
   }   
   
   public String showPrice(){    
    return "白银价格为:"+this.price;
   }
}



package ding.study.designpatterns.observer;

import java.util.Scanner;

/**
 * 观察者模式(发布-订阅):定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，
 * 使它们能够自动更新自己。
 * 
 * @author daniel
 * @email 576699909@qq.com
 * @time 2016-6-18 下午4:01:28
 */
public class ATestMain {

	/**
	 * @author daniel
	 * @time 2016-6-18 下午4:00:56
	 * @param args
	 */
	public static void main(String[] args) {
		AgPrice ag = new AgPrice(7.5);
		AgObserver linYiFu = new AgObserver("观察者 林毅夫");
		AgObserver song = new AgObserver("观察者 宋鸿兵");
		AgObserver lang = new AgObserver("观察者 郎咸平");
		ag.addObserver(linYiFu);
		ag.addObserver(song);
		ag.addObserver(lang);
		// System.out.println(ag);
		// ag.setPrice(7.8);
		// System.out.println(ag);
		while (true) {
			System.out.println("\n\n请输入就最新价格：");
			Scanner scanner = new Scanner(System.in);
			String str = scanner.nextLine();
			if (str.equals("exit")) {
				System.out.println("结束");
				break;
			}
			System.out.println("您输入的价格为:" + str);
			ag.setPrice(Double.valueOf(str));
		}
	}
}

输出

请输入就最新价格：
6
您输入的价格为:6
观察者 郎咸平观察到的价格更改为
6.0
观察者 宋鸿兵观察到的价格更改为
6.0
观察者 林毅夫观察到的价格更改为
6.0

源码 

https://github.com/dingsai88/StudyTest/tree/master/src/ding/study/designpatterns/observer