观察者模式实现

手写观察者模式

/**
 * 抽象目标类， 抽象被观察者
 */
public abstract class Subect {

    List<AbsObserver> observers = new ArrayList<>();

    public void add(AbsObserver absObserver){
        observers.add(absObserver);
    }

    public void remove(AbsObserver absObserver){
        observers.remove(absObserver);
    }

    public abstract void change();

}

/**
 * 具体目标类（被观察者）
 */
public class ConcreateSubject extends Subect{

    @Override
    public void change() {
        System.out.println("具体目标发生改变...");
        System.out.println("--------------");
        for (Object obs : observers) {
            ((AbsObserver) obs).update();
        }

    }
}

/**
 * 抽象观察者
 */
public interface AbsObserver {
    void update();
}

/**
 * 具体观察者
 */
public class ConcreateObserver implements AbsObserver{
    @Override
    public void update() {
        System.out.println("具体观察者收到通知");
    }
}

// 测试
public static void main(String[] args) {
        Subect subect = new ConcreateSubject();
        AbsObserver observer = new ConcreateObserver();
        subect.add(observer);
        subect.change();
    }

java 中有定义 Observable Observer 实现观察者模式

public class Observer1 implements Observer {

    @Override
    public void update(Observable o, Object arg) {
        System.out.println("Observer1 get change message" + o.toString() );
        if (arg!=null) System.out.println("得到的内容时："+arg);
    }

}

public class Observer2 implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("Observer2 get change message");
    }
}

public class Subject1 extends Observable {

    public void change(){
        System.out.println("Subject1 发生了改变");
        setChanged();
        notifyObservers();
    }

}

public class Subject2 extends Observable {

    public void alsoChange(){
        System.out.println("Subject2 发生了改变");
        setChanged();
        notifyObservers("123");
    }
}

    public static void main(String[] args) {
        Observer1 observer1 = new Observer1();//观察者1
        Observer2 observer2 = new Observer2();//观察者2
        Subject1 subject1 = new Subject1();//目标1
        subject1.addObserver(observer1);//注册观察者1
        subject1.addObserver(observer2);//注册观察者2
        subject1.change();//测试当目标1发生变化时观察者是否会跟着发生变化
        Subject2 subject2 = new Subject2();
        subject2.addObserver(observer1);
        subject2.alsoChange();
    }

观察者模式是一种对象行为型模式，其主要优点
降低了目标与观察者之间的耦合关系，两者之间是抽象耦合关系。符合依赖倒置原则。
目标与观察者之间建立了一套触发机制。

它的主要缺点
目标与观察者之间的依赖关系并没有完全解除，而且有可能出现循环引用。
当观察者对象很多时，通知的发布会花费很多时间，影响程序的效率。

代码地址