Java 观察者模式

import observerPattern.IObserver;
import observerPattern.Message;
import observerPattern.Person;
import observerPattern.Water;
import observerPattern_simple.*;
/**
 * 主程序类
 * Java中的观察者模式
 * 作者：Ai
 * 时间:2018年4月29日12:56:33
 */
public class DoMain {
    public static void main(String[] args){
        /**
         * 1.java中的消息传递机制是基于观察者模式的
         * 2.消息机制就是在监听某一事物，在其变化时，让观察者的行为随之变化，所以我们先写个观察者模式
         */

        //region 0.先写个简易的观察者模式
        //先来个观察者对象
        Observer observer=new Observer("观察者A");
        //再来个被观察者对象
        Observable listening=new Observable();
        //为被监听对象添加观察者
        listening.setObserver(observer);
        //变更被监听对象的状态
        listening.setChage(true);
        /**
         * 观察发现，每次监听对象的改变都会造成观察者内部的变化,
         * 其实就是在监听对象状态改变的时候给观察者一个消息，告诉观察者我状态变了
         * 然后观察者会对给出的消息进行处理
         * 存在的问题：
         * 1..这样监听对象只能被一个观察者监听
         * 2..监听对象和观察者应该被抽象为一种特性，所有对象都可能具有这种特性
         * 3..针对不同的观察者发现监听对象状态发生改变之后，应该能够采取不同的行为
         */
        //endregion

        //region 所以我们来改良观察者模式
        //先来个几个人（观察者
        IObserver person=new Person("小明");
        IObserver person1=new Person("小红");
        IObserver person2=new Person("小东");
        //再来个被观察对象
        observerPattern.Observable water=new Water();
        //为水添加观察的人
        water.addObsever(person);
        water.addObsever(person1);
        water.addObsever(person2);
        //状态改变(打开热水器开关,并将开始加热的消息传递给观察者
        water.setChange(true, Message.开始加热);
        water.setChange(true,Message.水50度了);
        water.setChange(true,Message.水100度了);
        //关闭热水器（并没有解除监听
        water.setChange(true,Message.关闭热水器);
        //小明离开了不再关注热水器
        water.removeObsever(person);
        //此时再加热
        water.setChange(true,Message.开始加热);
        /**
         * 可以发现在使用接口和抽象类后，观察者和被观察对象的这种特性，被很好的抽象出来
         * 我们可以通过多态很方便的实现对于不同情况的处理，易于扩展和维护
         */
        //endregion




    }
}

观察者

package observerPattern_simple;

/**
 * 观察者
 */
public class Observer {
    private String name;
    public Observer(String name){
        this.name=name;
    }
    public void update(){
        System.out.println("被观察者状态改变了__"+name);
    }
}

被观察对象

package observerPattern_simple;

/**
 * 被观察对象
 */
public class Observable {
    private Observer observer;
    private boolean isChage;

    /**
     * 设置观察者
     * @param observer 观察者对象
     */
    public void setObserver(Observer observer){
        this.observer=observer;
    }

    /**
     * 移除观察者
     */
    public void removeObserver(){
        if (this.observer!=null){
            observer=null;
        }
    }

    /**
     * 设置状态并触发状态改变
     * @param isChage
     */
    public void setChage(boolean isChage){
        this.isChage=isChage;
        update();

    }

    /**
     * 更新状态
     */
    private void update(){
        if (isChage&&observer!=null){
            observer.update();
            isChage=false;
            System.out.println("被观察者状态改变了"+"__被观察者");
        }
    }
}

接口及实体类

package observerPattern;

/**
 * 观察者接口
 */
public interface IObserver {
    /**
     * 状态改变时执行的动作
     */
    void update(Message data);
}

package observerPattern;

/**
 * 消息枚举,一些消息的集合
 */
public enum Message {
    开始加热,
    关闭热水器,
    水50度了,
    水60度了,
    水100度了
}

package observerPattern;

import java.util.*;

/**
 * 被观察者抽象类
 */
public abstract class Observable {
    protected boolean isChange;
    /**
     * 观察者列表
     * 用一个列表来存储监听此对象的所有监听者
     */
    //用Set集合的子类来存储不重复观察者对象
    protected Set<IObserver> observerList=new HashSet<>();

    /**
     * 添加观察者
     * @param observer
     */
    public void addObsever(IObserver observer){
        observerList.add(observer);
    }

    /**
     * 移除观察者
     * @param observer
     */
    public void removeObsever(IObserver observer){
        if (observerList.contains(observer))
        observerList.remove(observer);
    }

    /**
     * 清空观察者列表
     */
    public void clearObserver(){
       observerList.clear();
    }

    /**
     * 设置状态
     * @param b
     */
    public void setChange(boolean b,Message message){
        this.isChange=b;
        if (b)
        notifyObservers(message);
    }
    /**
     * 驱动进行状态更新（消息传递
     */
    private void notifyObservers(Message message){
        if (isChange){
            for (IObserver observer:observerList) {
                observer.update(message);
            }
        }
        isChange=false;
    }


}

package observerPattern;

/**
 * 人类，作为观察者
 */
public class Person implements IObserver {
    private String name;
    public Person(String name){
        this.name=name;
    }
    @Override
    public void update(Message data) {
        System.out.println(data+"__"+name);
    }
}

package observerPattern;

/**
 * 水类，在此类中能够重写被观察者的方法
 */
public class Water extends Observable {

}

---

谢谢大家能够看到这里（坚持就是胜利）

以上为观察者模式。

此文是我2018年所写，上传供大家学习，后续会增加一些说明和解释。