观察者模式

定义：

        定义了对象之间一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并被自动更新。

适用场景：

       1、对象间存在一对多关系，一个对象的状态发生改变会影响其他对象。

       2、当一个抽象模型有两个方面，其中一个方面依赖于另一方面时，可将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。

优点：

       1、降低了目标与观察者之间的耦合关系，两者之间是抽象耦合关系。

       2、降低了目标与观察者之间的耦合关系，两者之间是抽象耦合关系。

缺点：

       1、目标与观察者之间的依赖关系并没有完全解除，而且有可能出现循环引用。

       2、当观察者对象很多时，通知的发布会花费很多时间，影响程序的效率。

组成元素：

       1、抽象主题（Subject）：也叫抽象目标类，它提供了一个用于保存观察者对象的聚集类，还包含增加、删除观察者对象的方法，以及通知所有观察者的抽象方法。

       2、具体主题（ConcreteSubject）：也叫具体目标类，它实现抽象目标中的通知方法，当具体主题的内部状态发生改变时，通知所有注册过的观察者对象

       3、抽象观察者（Observer）：它是一个抽象类或接口，它包含了一个更新自己的抽象方法，当接到具体主题的更改通知时被调用。

       4、具体观察者（ConcreteObserver）：实现抽象观察者中定义的抽象方法，以便在得到目标的更改通知时更新自身的状态。

类图如下：

抽象代码如下：

       1、定义抽象观察者Observer：

public interface Observer {

	public void response();
}

       2、定义两个具体的观察者ConcreteObserver1、ConcreteObserver2：

public class ConcreteObserver1 implements Observer{

	@Override
	public void response() {
		System.out.println("我是观察者1，我自身得到了更新");
	}
}

public class ConcreteObserver2 implements Observer{

	@Override
	public void response() {
		System.out.println("我是观察者2，我自身得到了更新");
	}
}

        3、定义抽象主题Subject：

public abstract class Subject {

	public List<Observer> observers = new ArrayList<Observer>();
	
	public  void add(Observer observer){
		observers.add(observer);
	}
	
	public  void remove(Observer observer){
		observers.remove(observer);
	}
	
	public abstract void notifyObserver();
}

       4、定义具体主题ConcreteSubject：

public class ConcreteSubject extends Subject{

	@Override
	public void notifyObserver() {
		for(Observer single:observers){
			single.response();
		}
	}
}

       5、测试代码如下：

public class TestMain {

	public static void main(String[] args) {
		
		Observer  o1 = new  ConcreteObserver1();
		Observer  o2 = new  ConcreteObserver2();
		
		Subject subject = new ConcreteSubject();
		
		subject.add(o1);
		subject.add(o2);
		
		subject.notifyObserver();
	}
}

       6、输出结果如下：

示例代码如下：

       现在几乎每个人都玩微信，微信里面有一个公众号功能，当你订阅一个公众号，当它有新的消息时，它会给你发送最新的消息，当你取消订阅的时候，它有新消息了也不会给你发送了。现在我们就以这个公众号为例，展示一下观察者模式。

       1、定义一个抽象观察者（微信）WeChat：

public interface WeChat {

	public void response(String message);
}

       2、定义两个具体的观察者（微信用户A）ConcreteWeChatA和（微信用户B）ConcreteWeChatB：

public class ConcreteWeChatA implements WeChat{

	@Override
	public void response(String message) {
		System.out.println("我是微信用户A，我得到的最新消息是"+message);
	}
}

public class ConcreteWeChatB implements WeChat{

	@Override
	public void response(String message) {
		System.out.println("我是微信用户B，我得到的最新消息是"+message);
	}
}

        3、定义抽象主题（公众号）Tencent：

public abstract class Tencent {

	public List<WeChat> weChatUsers = new ArrayList<WeChat>();
	
	public  void add(WeChat weChat){
		weChatUsers.add(weChat);
	}
	
	public  void remove(WeChat weChat){
		weChatUsers.remove(weChat);
	}
	
	public abstract void notifyObserver(String message);
}

       4、定义具体主题ConcreteTencent：

public class ConcreteTencent extends Tencent{

	@Override
	public void notifyObserver(String message) {
		for(WeChat single:weChatUsers){
			single.response(message);
		}
	}
}

       5、测试代码如下：

public class TestMain {

	public static void main(String[] args) {
		
		WeChat  w1 = new  ConcreteWeChatA();
		WeChat  w2 = new  ConcreteWeChatB();
		
		Tencent subject = new ConcreteTencent();
		
		subject.add(w1);
		subject.add(w2);
		
		subject.notifyObserver("明天黄金涨价");
	}
}

       6、输出结果如下： 

jdk中自带的观察者模式 

               主题使用的是Observable类，而我们的定义的主题是一个接口，所以说jdk自带的观察者模式易用性较低(jdk自带的)

               观察者使用的是Observer接口(jdk自带的)