设计模式 观察者模式

一.回调函数

回调函数是理解事件监听器 和 观察者模式的前提

什么是回调函数

所谓的回调，用于回调的函数。 回调函数只是一个功能片段，由用户按照回调函数调用约定来实现的一个函数。 有这么一句通俗的定义：就是程序员A写了一段程序（程序a），其中预留有回调函数接口，并封装好了该程序。程序员B要让a调用自己的程序b中的一个方法，于是，他通过a中的接口回调自己b中的方法。

这里涉及三个实体：回调抽象接口，回调者a
一般都是被回调者实现回调接口，回调者进行调用
例如：
创建回调者

public class View {         //回调类
    private Listener listener ;
    public void setListener(Listener _listener){ 
        listener = _listener;
    }
    public void Click() {
        listener.notifydothing();
    }
    interface Listener {     //回调接口
         void notifydothing();
    }
}

方式一：匿名对象实现

View view = new View();
view.setListener(new View.Listener() {
@Override
public void notifydothing() {
      System.out.println("<<<<----方式一实现  notifydothing---->>>>>");
     }
        });

//模拟回调者调用
view.Click();

方式二：实现接口 实现

public class Main1 implements View.Listener{

    View view1 = new View();
    view1.setListener(this);
    //模拟回调者调用
    view1.Click();

    @Override
    public void notifydothing() {
        System.out.println("<<<<----方式二实现  notifydothing---->>>>>");
    }

方式三： 内部类实现

public class Main implements View.Listener{

    public static void main(String[] args) {
        //方式3 内部类实现
        View view2 = new View();
        Listener listener = new Listener();
        view2.setListener(listener);
        //模拟回调者调用
        view2.Click();

    }
    static class Listener implements View.Listener {
        @Override
        public void notifydothing() {
            System.out.println("<<<<----方式三实现  notifydothing---->>>>>");
        }
    }
}

二.观察者模式

该模式包含三个角色： 观察者 被观察者 主题
关系：一个被观察者 多个观察者 （一对多）
理解：起始就是发布订阅模式，发布者发布信息，订阅者获取信息，订阅者订阅了消息就能收到消息，没有订阅就不能收到消息，发布者和订阅者是 一对多的关系。

例如：
1个被观察者 3个观察者

public interface Listener {
    void nothdothing(String string);
}

被观察者

public class Manager {
    private static String TAG = "listener";
    public static Manager manager;
    private List<Listener> listeners = new ArrayList<>();

    private Manager() {
        System.out.println("Mangeer create");
    }

    public static Manager getInstance() {
        System.out.println("Mangeer getInstance");
        if (manager == null) {
            manager = new Manager();
        }
        return manager;
    }

    public void addListener(Listener _listener) {
        if (!listeners.contains(_listener)) {
            System.out.println("add listener");
            listeners.add(_listener);
        }
    }

    public void removeListener(Listener listener){
        if(listeners.contains(listener)) {
            System.out.println("remove listener");
            listeners.remove(listener);
        }
    }

    public void removeAllListener() {
        listeners.clear();
    }

    public void notifydothing() {
        for (Listener listener:listeners) {
            listener.nothdothing("发送通知");
        }
    }
}

观察者1

public class Model implements Listener{
    private static String TAG = "listener";
    private Manager manager;
    public Model() {
        manager = Manager.getInstance();
    }

    //方式1 通过 this
    public void addListener1() {
        manager.addListener(this);
    }

    public void removeListener1() {
        manager.removeListener(this);
    }

    @Override
    public void nothdothing(String string) {
        System.out.println("方式1 nothdothing: "+string);
    }
}

观察者2

public class Model1 {
    private static String TAG = "listener";
    private Manager manager;
    public Model1() {
        manager = Manager.getInstance();
    }

    //方式2 通过内部类
    private Listener1 listener = new Listener1();
    public void addListener2() {

        manager.addListener(listener);
    }
    public void removeListener2() {
        manager.removeListener(listener);
    }


    class Listener1 implements Listener{
        @Override
        public void nothdothing(String string) {
            System.out.println("方式2 nothdothing: "+string);
        }
    }
}

观察者3

public class Model2 {
    private static String TAG = "listener";
    private Manager manager;
    public Model2() {
        manager = Manager.getInstance();
    }

    //方式3 通过匿名对象
    public void addListener3() {
        manager.addListener(new com.example.callback.listener1.Listener() {
            @Override
            public void nothdothing(String string) {
                System.out.println("方式3 nothdothing: "+string);
            }
        });
    }
    public void removeListener3() {
        //方式3 无法移除
    }
}

Main.java

public class Main {
    public static void main(String[] args) {

        //观察者和被观察者是多对1关系
        //创建被观察者
        Manager manager = Manager.getInstance();

        //创建观察者1
        System.out.println("---------方式1----------");
        Model model = new Model();
        manager.addListener(model);

        //创建观察者2(常用)
        System.out.println("---------方式2----------");
        Model1 model2 = new Model1();
        model2.addListener2();


        //创建观察者3
        System.out.println("---------方式3----------");
        Model2 model3 = new Model2();
        model3.addListener3();


        //移除观察者
        System.out.println("---------移除----------");
        manager.removeListener(model);
        model2.removeListener2();
        model3.removeListener3();
        manager.removeAllListener();
    }
}