理解【观察者模式】的正确姿势

1、

观察者，观察者，顾名思义，就是由一拨人观察一些东西，所以两个东西就诞生了，那就是：人、东西

既然是一拨人，比如说这些人有，小王，小刘，等等

那么我们首先，第一件事情就是创建这些人

小王类 小王 = new 小王类();
小刘类 小刘 = new 小刘类();

我们还需要有观察的东西，比如说这些人会说话，就是听什么，说什么

class 小王类{
	void 说话(String 话) {
		System.out.println(话);
	}
}

class 小刘类{
	void 说话(String 话) {
		System.out.println(话);
	}
}

2、

那他们怎么去观察呢，反过来就是你要把一件事情告诉他们，怎么告诉？

举个例子

public class Main {
    public static void main(String[] args) throws IOException {
		小王类 小王 = new 小王类();
		小刘类 小刘 = new 小刘类();

		小王.说话("啦啦啦啦啦");
		小刘.说话("啦啦啦啦啦");
    }
}

这样就可以了

3、

但是，我们继续想，我们要保证每个人都会说话，如果小王不会说话，但是你调用小王的 “说话” 方法，一定会报错的，怎样来保证他们都具有说话的方法呢？

当然是让他们都继承一个东西，或者实现什么东西，这样就能强制让他们都有 “说话” 这个方法了

那好，我们就随便起个名字，比如说就是观察者，在里面定义一个方法，就可以保证所有的孩子都具有说话这个方法了

interface 观察者 {
	void 说话(String 话);
}

下面，我们必须让小王和小刘继承这个接口

class 小王类 implements 观察者{
	@Override
	void 说话(String 话) {
		System.out.println(话);
	}
}

class 小刘类 implements 观察者{
	@Override
	void 说话(String 话) {
		System.out.println(话);
	}
}

这样就保证了在main方法访问的时候不出现访问不到的情况了

4、

但是还有一个问题，就是如果用户太多了，怎么办了，比如说又来了小张、小李。。。。

public class Main {
    public static void main(String[] args) throws IOException {
		小王类 小王 = new 小王类();
		小刘类 小刘 = new 小刘类();
		小张类 小张 = new 小张类();
		小李类 小李 = new 小李类();

		小王.说话("啦啦啦啦啦");
		小刘.说话("啦啦啦啦啦");
		小张.说话("啦啦啦啦啦");
		小李.说话("啦啦啦啦啦");
    }
}

这就太乱了，太多了，如果有100个，那还要写到什么时候了

好吧，我们一怒之下，写一个管理他们的类，然后把他们都放到一起，然后一起通知

知道了需求之后，我们来想一下，既然要把他们都放到一块，那么我们必须要有一个放他们的容器，就是那什么放

ArraList<>

写不下去了，我们要把他们都放到容器里面，但是我们不知道他们是什么类型，我们没办法放，但是转念一想，刚才我们定义了一个 “观察者” 类，来把他们都统筹放到一块，所以不管是小张、小王、小刘。。。他们一定都是“观察者”类型

ArraList<观察者> 名单 = new ArrayList<观察者>();

这样，我们就建立了一个容器，来放置小张、小王、小刘。。。

5、

那要通知他们怎么办了?

直接利用容器的循环遍历就可以了

for (观察者 每个人 : 名单) {	#在名单中来遍历每个人，然后通知他们
    每个人.说话("啦啦啦啦啦啦");	#调用每个人的说话方法
}

好了，现在我们就实现的完全自动化了

除此之外，我们添加一些加入啦，删除啦，等等这些方法

class 管理类{
	ArraList<观察者> 名单 = new ArrayList<观察者>();

	void 刷新(String 话){
		for (观察者 每个人 : 名单) {	#在名单中来遍历每个人，然后通知他们
		    每个人.说话("啦啦啦啦啦啦");	#调用每个人的说话方法
		}
	}
}

现在，我们在main方法中

public class Main {
    public static void main(String[] args) throws IOException {
		小王类 小王 = new 小王类();
		小刘类 小刘 = new 小刘类();
		小张类 小张 = new 小张类();
		小李类 小李 = new 小李类();
		
		管理类 管理对象 = new 管理类();

		管理对象.添加(小王);	# 由于不是主要部分，就不实现了
		管理对象.添加(小刘);
		管理对象.添加(小张);
		管理对象.添加(小李);
		
		管理对象.刷新("啦啦啦啦啦");
    }
}

好的，现在我们就实现了统一的管理，只要添加进去，我们就可以随意喊话了

管理对象.刷新("啦啦啦啦啦");
管理对象.刷新("啦啦啦啦啦啦啦啦啦");
管理对象.刷新("啦啦啦啦啦啊啊啊啊啊啊啊啊啊");
管理对象.刷新("啦啦啦啦啦咔咔咔咔咔咔咔咔咔咔咔咔咔咔咔咔咔");

只要我们写这样的几句话，所有的成员都会叫

6、

那么如果有多个管理，怎么办呢？和前面一样的思路，把必须要的功能写成接口，这样就可以保证规范了

interface 管理类接口{
	void 添加观察者(观察者 成员); //这里虽然写的是观察者，但是我们添加的时候是添加的具体的小王、小刘、等等，只不过他们都是观察者类型，所以就简写为这样了
	void 删除观察者(观察者 成员);//这里虽然写的是观察者，但是我们添加的时候是添加的具体的小王、小刘、等等，只不过他们都是观察者类型，所以就简写为这样了
	void 刷新();
}

这样，我们就实现了完整的观察者模式，