文章目录

前言接口回调、观察者模式、RxJava1. 接口回调2. 观察者模式3. RxJava

前言

一步一步，似爪牙，似魔鬼的步伐。

接口回调、观察者模式、RxJava

1. 接口回调

作为一个安卓开发，这玩意，洒家几乎是天天在用，用的多了，就产生了一些莫名其妙的感悟。啊，本质不就是函数调用么，啥花里胡哨的，各种举栗子，人都晕了。与其举栗子，还不如说说我们为什么要这个接口，正常如下。

当 A B 两者都是已知的，是同一个程序员写的，我们这样调用是可行的，可以，双方互调畅通无阻，自己写的代码，想咋写就咋写。形参，类名，方法，想改就改。（不考虑其他）

但，我们都知道，我们开发中会遇到各种第三方库及不可修改的代码，那坏事了，写 B 类的程序员如何设置他方法中的变量类型？怎样传递信息给A类？

这时，接口就出来了，留个接口， A 类中实现这个接口，这样，我们就能确定 A 类了。他的父类，他一定会实现的方法我们都知道了，接口就是干这种活的最佳选择。

?对不起，此时我有个很好的栗子必须得举一举。

情景一（面对面） 就如同开始讲的，面对面，你喊我，我喊你，直接喊就行了。情景二（异地沟通） 异地，我们当然不能直接喊话了，但是，B 留了个电话号码 （接口），A 通过这个号码发信息给 B ,此时 B 的联系方式也暴露给了 A， 这样 A B 就可以沟通了。情景三（异地沟通 ，异步，耗时操作） 实际上，信息不是一发送就能得到回应的，会耗时间，没收到消息，我们自然也不会干等，所有实际中，这个过程，很多都是多线程，异步的。

定义一个接口，并确定一个必要的回调方法。

interface CallBack { void Notice(String str); }

B 类接到消息后，开启一个线程执行任务，callback 相当于来电显示，其引用地址是 A 类中匿名内部类的。

public class B { private CallBack callBack; private Boolean doSomeThing(String str) { for (int i = 0; i < new Random().nextInt(20); i++) { System.out.println("B 正在执行任务：" + str+"--"+i); if (i>10){ System.out.println("B "+str+"失败"); return false; } } System.out.println("B "+str+"成功"); return true; } public void Call(String str, CallBack callBack) { System.out.println("B 收到消息：" + str + "，来源" + callBack.toString()); this.callBack = callBack; new Thread(new Runnable() { @Override public void run() { if (B.this.doSomeThing(str)) { callBack.Notice(str + "完成"); } else { callBack.Notice(str + "失败"); } } }).start(); } }

实例化 B 类 通知 其做事，并用匿名内部类实现了 CallBack 接口。

public class A { public static void main(String[] args) { B b = new B(); b.Call("充电费",new CallBack() { @Override public void Notice(String str) { System.out.print("A 收到 B 的消息："+str); } }); for (int i = 0; i < 10; i++) { System.out.println("A 做其他的事，如看电视" + i); } } }

2. 观察者模式

我为什么要把这个放一起，因为我感觉接口回调和观察者模式的区别就是： private CallBack callBack; → protected ArrayList observers=new ArrayList<>(); 之前 1 对 1 发短信，现在 1 对多 发短信。

观察者模式（有时又被称为模型-视图（View）模式、源-收听者(Listener)模式或从属者模式）是软件设计模式的一种。在此种模式中，一个目标物件管理所有相依于它的观察者物件，并且在它本身的状态改变时主动发出通知。这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实现事件处理系统。

包含角色：

Subject（目标）ConcreteSubject（具体目标）Observer（观察者）ConcreteObserver（具体观察者）

Emmmm 貌似很简单的样子,没有想象中的那么复杂，但就定义来说，哈哈，还是不同的。我脸盲。

之前，我还从设计模式一书中，抄了一个例子。

接口还是重要，制定标准。

//抽象观察者类 interface Observer{ void response(); }

抽象类是半成品，介于接口和类之间。

//抽象目标 abstract class Subject{ protected ArrayList<Observer> observers=new ArrayList<>(); //注册方法 public void attach(Observer observer) { observers.add(observer); } //注销方法 public void detach(Observer observer) { observers.remove(observer); } public abstract void cry(); }

具体的目标类

class ConcreteSubject extends Subject{ @Override public void cry() { // TODO Auto-generated method stub System.out.println("发起事件源"); for(Object obs:observers) { ((Observer)obs).response(); } } }

具体的观察者

class ConcreteObserverA implements Observer{ @Override public void response() { // TODO Auto-generated method stub System.out.println("事件响应A"); } }

忽略 ConcreteObserverB 代码跟 A 差不多，就是改了个名字。

ConcreteObserverA ca = new ConcreteObserverA(); ConcreteObserverB cb = new ConcreteObserverB(); ConcreteSubject s = new ConcreteSubject(); s.attach(ca); s.attach(cb); s.attach(new Observer() { @Override public void response() { System.out.println("匿名内部类"); } }); s.cry();

哈哈，Rxjava就是基于观察者模式的。 所以我弄了点骚的，模拟了一下Rxjava。

public class Test { public static void main(String[] args) { ConcreteObserverA ca = new ConcreteObserverA(); ConcreteObserverB cb = new ConcreteObserverB(); ConcreteSubject s = new ConcreteSubject(); s.attach(ca); s.attach(cb); s.attach(new Observer() { @Override public void response() { System.out.println("匿名内部类"); } }); s.cry(); //模仿一波 ConcreteSubBject2 concreteSubBject2 = new ConcreteSubBject2(); concreteSubBject2.create(new ObservableOnSubscribe() { @Override public void subscribe() { System.out.println("发起"); } }).attach(new Observer() { @Override public void response() { System.out.println("响应"); } }); // concreteSubBject2.cry(); } } class ConcreteSubBject2 extends Subject { private ObservableOnSubscribe subscribe; @Override public void cry() { subscribe.subscribe(); System.out.println("发起事件源"); for (Object obs : observers) { ((Observer) obs).response(); } } public ConcreteSubBject2 create(ObservableOnSubscribe subscribe) { this.subscribe = subscribe; return this; } } interface ObservableOnSubscribe { void subscribe(); }

3. RxJava

前面的都是配菜，其实我想理解的是RxJava，真的难么？有网有如下说道。 百度了一下，我觉得 RxJava沉思录写的是真不错。

RxJava2.0——从放弃到入门 RxJava 沉思录（一）：你认为 RxJava 真的好用吗？ RxJava 沉思录（二）：空间维度 RxJava 沉思录（三）：时间维度 RxJava 沉思录（四）：总结

这篇其实也不是教学文章，我的目的是通过写文章的方式，获得一些感悟，记录一些必要的知识点。 RxJava ,我也有了一些使用经验，理解上也算到位了，但真正制约我的，是它的那些类名。

被观察者（Observable）观察者（Observer）订阅（subscribe）

咋一看，我是懵的，跟脸盲症患者差不多，这才三个，加上支持背压的那些，那感觉，就是让我在韩国女团里把某某找出来，太像的单词，我容易记混，容易看劈叉。

RxJava2 五大重要角色介绍

RxJava2 只看这一篇文章就够了 先理解吧，使用上的话，日后在说。