观察者模式学习笔记（详细）
一、什么是观察者模式
观察者模式，是定义对象之间的一对多的关系，主要作用是减少对象之间的耦合度，分为两个角色
- 被观察者：其实就是发布者，发布消息通知所有的观察者
- 观察者：接到被观察者发布的消息做出相应的动作
上图中，左边一组是被观察者，右边一组是观察者
-
Subjecct：被观察者抽象类，拥有类成员ObserverList，和三个抽象方法
ObserverList：存放所有的观察者对象
addObserver()：向ObserverList中添加观察者对象
delObject()：从ObserverList中删除观察者对象
notifyObservers()：通知所有的观察者对象 -
SubjectItem：具体的被观察者类，继承Subject接口，有具体的动作方法，调用父类的notifyObject()方法通知所有的观察者
-
Observer：观察者接口，有一个抽象方法update()，供被观察者调用
-
ObserverItem：具体的观察者类，实现Observer类，实现update()方法
二、使用场景
游戏中，被观察者主角有所动作就通知观察者们
支付中，一个商品购买成功，需要执行许多操作（更新订单，发送邮件，更新账户…），这时就可以使用观察者模式来减少耦合
再比如，关注动态，动态更新，需要发送通知给所有的关注者
三、具体实现
简单的一个冒险游戏，勇者做为被观察者，观察者有怪物，食物，NPC
当勇者移动碰到怪物时血量减1，碰到食物时血量加1，碰到NPC时展开剧情
- 编写Observer接口
public interface Observer {
public void update();
}
- 编写Subject抽象类
public abstract class Subject {
//观察者集合
private List<Observer> observerList = new ArrayList<>();
//添加观察者
public void addObserver(Observer observer){
observerList.add(observer);
}
//删除观察者
public void delObserver(Observer observer){
observerList.remove(observer);
}
//通知所有观察者
public void notifyObservers(){
for(Observer observer : observerList){
observer.update();
}
}
}
observerList集合存放了观察者接口，不直接存放观察者类
notifyObservers()方法遍历observerList集合，调用update()方法
通过抽象层减少耦合
- 编写勇者类（被观察者）
public class Hero extends Subject {
static int X = 0;
static int Y = 0;
//勇者移动
public void move(int x, int y){
X = x;
Y = y;
super.notifyObservers();
}
}
Hero类有move()方法，让勇者移动并调用父类的notifyObservers()方法通知所有的观察者
- 编写怪物类（观察者）
public class Monster implements Observer {
static int X = 5;
static int Y = 7;
@Override
public void update() {
if(Hero.X == X && Hero.Y == Y){
System.out.println("怪物攻击勇者！");
}
}
}
Monster类实现Observer接口，实现具体的update()方法
- 编写食物类（观察者）
public class Food implements Observer {
static int X = 8;
static int Y = 8;
@Override
public void update() {
if(Hero.X == X && Hero.Y == Y){
System.out.println("勇者吃到了食物，血量加1！");
}
}
}
Food类实现Observer接口，实现具体的update()方法
- 编写npc类（观察者）
public class Npc implements Observer {
static int X = 15;
static int Y = 20;
@Override
public void update() {
if(Hero.X == X && Hero.Y == Y){
System.out.println("勇者遇到NPC，剧情展开！");
}
}
}
Npc类实现Observer接口，实现具体的update()方法
- 编写执行类
public class Run {
public static void main(String[] args){
//初始化对象
Hero hero = new Hero();
Monster monster = new Monster();
Food food = new Food();
Npc npc = new Npc();
//添加观察者
hero.addObserver(monster);
hero.addObserver(food);
hero.addObserver(npc);
//勇者移动,遇到怪物
hero.move(5,7);
//勇者移动,吃到食物
hero.move(8,8);
//勇者移动,遇到npc
hero.move(15,20);
}
}
勇者移动时通知了所有已注册的观察者，执行各自的update方法
- 运行结果
四、总结
-
优点：
使用抽象的方式来减少被观察者和观察者之间的耦合，可以方便的增加观察者 -
缺点：
如果被观察者有过多的直接观察者和间接观察者的话，会花费更多的时间，如果观察者之间存在循环依赖的话，会导致他们直接进行循环调用，最终导致系统崩溃
观察者可以知道被观察者发生的变化，但是无法知道被观察者是如何发生的变化
