OOA与OOD与observer(观察者模式)

学习尚学堂设计模式总结：

帮助：

             1，理解什么是面向对象分析和面向对象设计

             2，观察者模式

             3，学会使用配置文件动态加载类

             4，单例模式的使用

 

OOA:

确认我们要实现的功能是什么。

OOD:

这个功能我们怎么去实现。

 

要求：

模拟下列情形
 *  1，小孩在睡觉
 *  2，醒来后要求不同的对象作出不同的反应

 

步骤：

我们把小孩设为观察，让它去观察对象，当它自己醒来后就要求不同的对象作出反应，就好像小孩的手上系了一根强绳在不同的对象上，让小孩自己去告诉这些对象，他已经醒来，并要求这些对象作出反应。这样有利于提高效率，其他对象可以做它自己想做的事，不用一直守候这个小孩。

下面是代码实现：

Test.java

package com.panlong.dp.observer;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Properties;

/**
 * 模拟下列情形
 *  1，小孩在睡觉 
 *  2，醒来后要求不同的对象作出不同的反应
 * @author pl
 *
 */
class Child implements Runnable{
	private List<WakenUpListener> wakenUpListeners = new ArrayList<WakenUpListener>();

	public void addWakenUpListener(WakenUpListener l){
		wakenUpListeners.add(l);
	}
	public void wakenUp(){
		for(Iterator<WakenUpListener> itor = wakenUpListeners.iterator();itor.hasNext();){
			WakenUpListener wakenUpListener = itor.next();
			wakenUpListener.ActionToWakenUp(new WakenUpEvent(System.currentTimeMillis(),"bed",this));
		}
	}

	@Override
	public void run() {
		try {
			Thread.sleep(5000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		wakenUp();
	}
	
}
class WakenUpEvent{
	private long time;
	private String loc;
	private Child source;
	
	
	public WakenUpEvent(long time, String loc, Child source) {
		this.time = time;
		this.loc = loc;
		this.source = source;
	}
	public long getTime() {
		return time;
	}
	public void setTime(long time) {
		this.time = time;
	}
	public String getLoc() {
		return loc;
	}
	public void setLoc(String loc) {
		this.loc = loc;
	}
	public Child getSource() {
		return source;
	}
	public void setSource(Child source) {
		this.source = source;
	}
	
}
class Dad implements WakenUpListener{
	public void ActionToWakenUp(WakenUpEvent w){
		System.out.println("feed child");
	}
}
class GrandFather implements WakenUpListener{
	public void ActionToWakenUp(WakenUpEvent w){
		System.out.println("hug child");
	}
}
class Dog implements WakenUpListener{

	public void ActionToWakenUp(WakenUpEvent w) {
		System.out.println("wang wang ----");
	}
	
}
interface WakenUpListener{
	public void ActionToWakenUp(WakenUpEvent w);
}
public class Test {

	public static void main(String args[]){
		Child c = new Child();
		String[] observers = PropertyMgr.getProperty("observers").split(",");
		for(String observer : observers){
//System.out.println(observer);
			try {
				c.addWakenUpListener((WakenUpListener) Class.forName(observer).newInstance());
			} catch (InstantiationException e) {
				e.printStackTrace();
			} catch (IllegalAccessException e) {
				e.printStackTrace();
			} catch (ClassNotFoundException e) {
				e.printStackTrace();
			}
		}
		new Thread(c).start();
		
	}
}
class PropertyMgr{
	private static Properties props = new Properties();
	//静态初始化只执行一次，提高效率
	static{
		try {
			props.load(Test.class.getClassLoader().getResourceAsStream("com/panlong/dp/observer/observer.properties"));
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	public static String getProperty(String key){
		
		return props.getProperty(key);
	}
}

observer.properties，内容：

observers=com.panlong.dp.observer.Dad,com.panlong.dp.observer.GrandFather,com.panlong.dp.observer.Dog