Java设计模式（观察者模式）

hello world! 大家好！

说到观察者模式，什么是观察者模式？一种一对多的依赖关系,让多个观察者对象同时监听某一主题对象,在它的状态发生变化时,会通知所有的观察者.

那观察者模式的优点优势是什麽？？观察者与被观察者之间是属于轻度的关联关系，并且是抽象耦合的，这样，对于两者来说都比较容易进行扩展。
观察者模式是一种常用的触发机制，它形成一条触发链，依次对各个观察者的方法进行处理。

然后，我就讲一下我的观察者模式实现：

首先是这样一个故事，一个偷鸡贼（哦，不！不能这么称呼人家）正在偷别人家的鸡或者狗。这时候正是被警察A和警察B看到，并在最后的角逐中小偷不行被逮！

其中，小偷（被观察者）、警察AB（观察者）；当小偷（被观察者）做出某些侮辱妇女行为，错了，是偷！～的行为，触发了警察AB（观察者）的底线并对小偷进行红色全球通缉。

接口 小偷（被观察者）：

public interface IThief {
    //注册观察者（类似注册监听）
    void registerPolice(IPolice police);
    //移去观察者（类似移走监听）
    void removePolice(WeakReference<IPolice> police);
    //notify通知报警方法
    void notifyPolice();

    //偷鸡
    void stealChicken();

    //摸狗
    void stealDog();
}

实现类 小偷（被观察者）：

public class DogThief implements IThief{
    public List<WeakReference<IPolice>> polices = new ArrayList<>();
    @Override
    public void registerPolice(IPolice police) {
        //第一步：必须先要进行监听的注册
        polices.add(new WeakReference<IPolice>(police));
    }

    @Override
    public void removePolice(WeakReference<IPolice> police) {
        int index = polices.indexOf(police);
        if(index >= 0){
            polices.remove(index);
        }
    }

    @Override
    public void notifyPolice() {
        for (int i = 0; i < polices.size(); i++){
            WeakReference<IPolice> weakPolice = polices.get(i);
            IPolice police = weakPolice.get();
            police.runAfterThief();//警察听到警报，追赶小偷
        }
    }


    @Override
    public void stealChicken() {
        System.out.println("警报：有小偷偷鸡了！！！");
        notifyPolice();
    }

    @Override
    public void stealDog() {
        System.out.println("警报：有小偷，摸狗了！！！");
        notifyPolice();
    }
}

接口 警察（观察者）：

//接口 警察
public interface IPolice {
    //追赶小偷
    void runAfterThief();

    //擒住小偷
    void catchThief();
}

对于小偷的行为进行处理的接口类：

public interface IJudgement {
    //对小偷的罪行进行判决
    void deadBShoot();//枪毙
}

public interface ILower {
    //作为律师对偷鸡摸狗贼 辩护
    void lowerPlead();
}

实现类 警察A（观察者）：

public class PoliceA implements IPolice, IJudgement {
    @Override
    public void runAfterThief() {
        System.out.println("呼哧呼哧。。。追赶小偷！！");

        catchThief();
    }

    @Override
    public void catchThief() {
        System.out.println("尼玛。。。逮着你了吧？！！");

        deadBShoot();//判决，拉出去枪毙
    }

    @Override
    public void deadBShoot() {
        //警察对该贼进行监视，最终对小偷的偷窃行为做出来自己的合理操作A
        System.out.println("哦！死了。。。");
    }
}

实现类 警察B（观察者）：

public class PoliceB implements IPolice, ILower{
    @Override
    public void lowerPlead() {
        //警察B对该贼进行监视，最终对小偷的偷窃行为做出来自己的合理操作
        System.out.println("我家猫贼，没偷鸡！！");
    }

    @Override
    public void runAfterThief() {
        System.out.println("呼哧呼哧。。。追赶小偷！！");
        catchThief();
    }

    @Override
    public void catchThief() {
        System.out.println("尼玛。。。逮着你了吧？！！");
        lowerPlead();
    }
}

小贼偷鸡摸狗，被警察发现并逮捕。然后俩警察分别对小贼做了相关处理！

public class MainText {
    public static void main(String[] args){
        PoliceA policeA = new PoliceA();
        PoliceB policeB = new PoliceB();

        DogThief dogThief = new DogThief();
        dogThief.registerPolice(policeA);
        dogThief.registerPolice(policeB);

        dogThief.stealChicken();//偷鸡
        dogThief.stealDog();//摸狗
    }
}

还有一种写法是使用java自带的接口和抽象类：抽象类（被观察者：Observable）、观察者（接口：Observer）

public class MainText {
    public static void main(String[] args){
        PoliceA policeA = new PoliceA();
        PoliceB policeB = new PoliceB();

        DogThief dogThief = new DogThief();
        dogThief.register(policeA);//注册A
        dogThief.register(policeB);//注册B
        dogThief.stealChickerDogs();// 开始偷鸡摸狗，触发警察AB的行为
    }
}

//被观察者（贼）
public class DogThief extends Observable {

    public void register(Observer observer){
        this.addObserver(observer);
    }
    public void stealChickerDogs(){
        System.out.println("偷鸡摸狗");
        this.notifyObservers();
    }
}

//观察者（警察A）
public class PoliceA implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("直接追上去逮住小偷");
    }
}

//观察者（警察B）
public class PoliceB  implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("打电话请求支援！");
    }
}

先将 Observer 注册到 Observable ，那么当 Observable 状态改变时会通知它持有的所有 Observer ,对了，最好 Observable 中的 mList 的泛型是 WeakReference ,防止内存泄漏；看图再理解一下：