观察者(Observer)模式类似于一种发布订阅,当一个对象改变,通知依赖对象。一对多进行观察（监听）,也可以相互观察
以博主与订阅者的关系为例:

/**
 * @description: 博主
 * @author: jiang
 */
public abstract class Blogger {
    /**
     * 订阅者列表
     */
    protected List<Subscriber> subscriberList = new ArrayList<Subscriber>();

    /**
     * 发布
     */
    abstract void release();

    /**
     * 添加订阅者
     * @param subscriber
     */
    public void addSubscriber(Subscriber subscriber){
        subscriberList.add(subscriber);
    }

    /**
     * 通知订阅者消息
     * @param msg
     */
    public void notifySubscriber(String msg){
        for (Subscriber subscriber:subscriberList) {
            subscriber.acceptMessage(msg);
        }
    }

}

/**
 * @description: 简书博主
 * @author: jiang
 */
public class JianShuBlogger extends Blogger{
    /**
     * 发布
     */
    @Override
    void release() {
        //写作
        //保存并发布
        notifySubscriber("简书上发布了一篇新文章,名为:《行为型-观察者模式》");
    }
}


/**
 * @description: 订阅者
 * @author: jiang
 */
public abstract class Subscriber {
    /**
     * 接收消息
     * @param msg
     */
    abstract void  acceptMessage(String msg);
    /**
     * 订阅博主
     */
    public void subscriberBlogger(Blogger blogger){
        blogger.addSubscriber(this);
    }
}

/**
 * @description: 简书订阅者
 * @author: jiang
 */
public class JianShuSubscriber extends Subscriber{
    /**
     * 接收消息
     * @param msg
     */
    @Override
    void acceptMessage(String msg) {
        System.out.println(msg);
    }
}

public static void main(String[] args) {
        Blogger blogger = new JianShuBlogger();

        Subscriber subscriber1 = new JianShuSubscriber();
        //订阅简书博主
        subscriber1.subscriberBlogger(blogger);
        Subscriber subscriber2 = new JianShuSubscriber();
        //订阅简书博主
        subscriber2.subscriberBlogger(blogger);

        //博主开始发表一篇文章
        blogger.release();
}
结果:
简书上发布了一篇新文章,名为:《行为型-观察者模式》
简书上发布了一篇新文章,名为:《行为型-观察者模式》