大话设计模式之观察者模式

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

Subject类为抽象通知者，一般用一个抽象类或者一个接口实现，它把所有对观察者对象的引用保存在一个聚集里，每个通知者都可以有任何数量的观察者。抽象通知者，可以增加和删除观察者对象。

Observer类，抽象观察者，为所有的具体观察者定义一个接口，在得到通知者通知时更新自己更新接口通常包含一个update方法

ConcreteSubject类，叫做具体通知者，将有关状态存入具体观察者对象：在具体通知者的内部状态改变时，给所有登记过的观察者发出通知

ConcreteObserver类，具体观察者，可以保存一个指向具体主题对象的应用

package Observer;

import java.util.ArrayList;
import java.util.List;

public class MainClass {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ConcreteSubject s = new ConcreteSubject();
		
		s.attach(new ConcreteObserver("x", s));
		s.attach(new ConcreteObserver("y", s));
		s.attach(new ConcreteObserver("z", s));
		
		s.setSubjectState("jack");
		s.Notify();
	}

}

abstract class Subject {
	private List<Observer> observers = new ArrayList<>();
	
	public void attach(Observer observer) {
		observers.add(observer);
	}
	
	public void detach(Observer observer) {
		observers.remove(observer);
	}
	
	public void Notify() {
		for (Observer o : observers) {
			o.update();
		}
	}
}

abstract class Observer {
	public abstract void update();
}

class ConcreteSubject extends Subject {
	private String subjectState;

	public String getSubjectState() {
		return subjectState;
	}

	public void setSubjectState(String subjectState) {
		this.subjectState = subjectState;
	}
}

class ConcreteObserver extends Observer {
	private String name;
	private String observerState;
	private ConcreteSubject subject;
	
	
	public ConcreteObserver(String name, ConcreteSubject subject) {
		this.name = name;
		this.subject = subject;
	}

	@Override
	public void update() {
		// TODO Auto-generated method stub
		observerState = subject.getSubjectState();
		System.out.println("observer1 state "+observerState);
	}

	public ConcreteSubject getSubject() {
		return subject;
	}

	public void setSubject(ConcreteSubject subject) {
		this.subject = subject;
	}
}

总的来说，就是对通知者抽象，对观察者抽象，通知者持有观察者集合，观察者持有通知者。

观察模式的特点：将一个系统分割成一系列相互协作的类，有一个很不好的副作用，那就是需要维护相关对象的一致性。我们不希望为了维持一致性而使各类紧密耦合，这样会给维护、扩展和重用都带来不变。在观察者模式中一旦Subject的状态发生了改变，所有的Observer都可以得到通知。

应用场景：当一个对象的改变需要同时改变其他对象的时候，而且不知道具体有多少对象有待改变时，应该考虑使用观察者模式。一个抽象模型有两个方面，其中一方面依赖于另一方面，这时观察者模式可以将这两者封装在独立的对象中使它们各自独立地改变和复用。

观察者模式所做的工作其实就是在解除耦合，让耦合的双方都依赖于抽象，而不是依赖于具体，从而使得各自的变化都不会影响另一边的变化

关于委托：委托就是一种引用方法的类型，一旦为委托分配了方法，委托将与该方法具有完全相同的行为。委托方法的使用可以像其他任何方法一样，具有参数和返回值。委托可以看作是对函数的抽象，是函数的类，委托的实例将代表一个具体的函数。委托对象所搭载的所有方法必须具有相同的原形和形式，也就是拥有相同的参数和返回类型。