观察者模式学习笔记（详细）

一、什么是观察者模式

观察者模式，是定义对象之间的一对多的关系，主要作用是减少对象之间的耦合度，分为两个角色

被观察者：其实就是发布者，发布消息通知所有的观察者
观察者：接到被观察者发布的消息做出相应的动作

上图中，左边一组是被观察者，右边一组是观察者

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方法

运行结果

四、总结

优点：
使用抽象的方式来减少被观察者和观察者之间的耦合，可以方便的增加观察者
缺点：
如果被观察者有过多的直接观察者和间接观察者的话，会花费更多的时间，如果观察者之间存在循环依赖的话，会导致他们直接进行循环调用，最终导致系统崩溃
观察者可以知道被观察者发生的变化，但是无法知道被观察者是如何发生的变化