设计模式之观察者模式

首先说了一个自己的小例子吧，前两天我的一个朋友来找我玩，因为路途比较远，我需要知道他的位置，然后安排好时间去接他，那么在这个例子中，我就是一个观察者，需要时时刻刻观察他的位置，我的朋友就是一个被观察者。那么需要知道我朋友的位置，就有两种方式，第一，我自己打电话问，第二，我的朋友告诉我，下面我们来看看这两种方式的实现。

首先第一种方式，我时时刻刻打电话问我的朋友

下面是观察者Me的定义

public class Me {
	private Friend friend;
	
	public Me(Friend friend)
	{
		this.friend = friend;
	}
	
	//我打电话给朋友，获取他的位置。在子线程来完成
	public void callFriend()
	{
		new GetLocationThread(friend).start();
	}
}

下面是获取位置子线程的定义

public class GetLocationThread extends Thread {
	
	private Friend friend;
	
	public GetLocationThread(Friend friend)
	{
		this.friend = friend;
	}
	
	public void run()
	{
		while(true)
		{
			try {
				Thread.sleep(2000);  //每隔两秒我就打一次电话。我的朋友都要烦死了
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			if(friend.getLeftStationCount() == 0)
			{
				System.out.println("我的朋友已经到了");
				return;
			}else
			{
				System.out.println("我的朋友还有"+friend.getLeftStationCount()+"站路到..");
			}	
		}
	}
}

下面是被观察者Friend的定义

public class Friend {

	private int leftStationCount = 10;//还有多少站能到

	public int getLeftStationCount() {
		return leftStationCount;
	}

	public void setLeftStationCount(int leftStationCount) {
		this.leftStationCount = leftStationCount;
	}

	//我的朋友也在赶紧走，他两秒也能走一站路。
	public void move()
	{
		for(int i = leftStationCount;i>-1;i-- )
		{
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			this.leftStationCount = i;
		}
	}
}

下面是场景类

public class Client {

	public static void main(String args[])
	{	
		Friend friend = new Friend();
		Me me = new Me(friend);
		me.callFriend();
		friend.move();
		
	}	
}

下面是输出的结果

但是一看就知道这种方式的不合理，显示生活中怎么可能让我时时刻刻去打电话去问我的朋友呢，应该是我的朋友到了直接通知我就好了，下面再来看第二种方式的实现

首先是观察者Me

public class Me {

	public void friendCome()
	{
		System.out.print("我的朋到了，我要去接他了....");
	}	
}

       然后是被观察者Friend

public class Friend {
	


	//我们同学聚会，有好多人他都要通知
	private List<Me> observers = new ArrayList<Me>();
	
	private int leftStationCount = 10;//还有多少站能到
	
	//告诉我的朋友，需要通知那些人
	public void addObserver(Me me)
	{
		observers.add(me);
	}
	
	public void move()
	{
		for(int i = leftStationCount;i>-1;i-- )
		{
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			this.leftStationCount = i;
			if(this.leftStationCount == 0) //到了，要通知所有的人了。
			{
				this.notifyAllObersers();
			}
			else
			{
				System.out.println("还有"+this.leftStationCount+"站路到..");
			}
		}
	}
	
	public void notifyAllObersers()
	{
		for(Me m:observers)
		{
			m.friendCome();
		}
	}
	
}

下面是场景类

public class Client {

	public static void main(String[] args) {
		Me me = new Me();
		Friend friend = new Friend();
		friend.addObserver(me);// 需要通知我
		friend.move();//朋友出发了

	}
}

下面简单的说一下观察者模式的定义：观察者模式也叫订阅者模式，它定义了对象间一种一对多的依赖关系，使得当一个对象改变的时候，所有依赖他的对象都会被通知并且自动更新。定义观察者必须实现的职责，它必须能动态的添加和取消观察者。以及在自己的状态发生改变之后，去通知观察者。作为观察者只需要定义好被通知时需要执行的方法即可。

文章系原创，转载请注明