系列文章
RxJava系列之简介和观察者设计模式
RxJava系列之上游与下游
RxJava系列之常用创建型操作符
RxJava系列之常用变换操作符
RxJava系列之常用过滤操作符
RxJava系列之常用条件操作符
RxJava系列之常用合并操作符
RxJava系列之常用异常操作符
RxJava系列之线程切换实战
RxJava系列之背压模式
RxJava系列之配合Retrofit
RxJava系列之泛型高级
RxJava系列之手写create操作符
RxJava系列之手写create操作符增加泛型限定
RxJava系列之手写just操作符
RxJava系列之手写map操作符
RxJava系列之手写切换线程
可读、可写模式 与上限下限的区别
如果有一个人类Person，有一个学生类Student，学生继承人，有一个职务类Job,继承学生 那么针对如下代码：
class Person{}
class Student extends Person{}
class Job extends Student{}
public void test(List<? extends Person> list) {
list.add(new Student()); // 编译不通过
list.add(new Job()); // 编译不通过
list.add(new Person()); // 编译不通过
list.add(new Object()); // 编译不通过
// 这个编译不通过就是因为<? extends Person>是可读模式
}
public void show(){
test(new ArrayList<Student>()); // 编译通过
test(new ArrayList<Job>()); // 编译通过
test(new ArrayList<Person>()); // 编译通过
test(new ArrayList<Object>()); // 编译不通过
}
对于调用这来说,这个泛型就是上限,他限定了你的入参的泛型必须是Person或者Person的子类。
再来看下面这个例子
class Person{}
class Student extends Person{}
class Job extends Student{}
public void test(List<? super Person> list) {
list.add(new Student()); // 编译通过
list.add(new Job()); // 编译通过
list.add(new Person()); // 编译通过
list.add(new Object()); // 编译不通过
// 这个编译通过就是因为<? super Person>是可写模式，传入Object对象编译失败 是因为不完全可写。
}
public void show(){
test(new ArrayList<Student>()); // 编译不通过
test(new ArrayList<Job>()); // 编译不通过
test(new ArrayList<Person>()); // 编译通过
test(new ArrayList<Object>()); // 编译通过
}
对于调用这来说,这个泛型就是 下限 ,他限定了你的入参的泛型必须是Person或者Person的父类。
具体学习可以参考下面链接
JAVA泛型知识（二）–> <? extends T>和<? super T>
加上界限限定的Observable
// todo 被观察者 上游
public class Observable<T> { // 类声明的泛型T Int
ObservableOnSubscribe source;
private Observable(ObservableOnSubscribe source) {
this.source = source;
}
// 静态方法声明的<T>泛型 ObservableOnSubscribe<T>==静态方法声明的<T>泛型
// 参数中：ObservableOnSubscribe<? extends T> 和可读可写模式没有任何关系，还是我们之前的那一套思想（上限和下限）
public static <T> Observable<T> create(ObservableOnSubscribe<? extends T> source) { // int
return new Observable<T>(source); // 静态方法声明的<T>泛型 int
}
// new Observable<T>(source).subscribe(Observer<Int>)
// 参数中：Observer<? extends T> 和可读可写模式没有任何关系，还是我们之前的那一套思想（上限和下限）
public void subscribe(Observer<? extends T> observer) {
observer.onSubscribe();
source.subscribe(observer);
}
}
加上类型限定的ObservableOnSubscribe
public interface ObservableOnSubscribe<T> { // T == String
// ? super 代表可写的 observableEmitter == 观察者
public void subscribe(Observer<? super T> observableEmitter); // Observer<String>
}
测试代码
// TODO 我们自己写的RxJava
public class MainActivity extends AppCompatActivity {
private final String TAG = MainActivity.class.getSimpleName();
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// 上游
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(Observer<? super Integer> observableEmitter) { // 使用到了，就产生了读写模式
Log.d(TAG, "subscribe: 上游开始发射...");
// 发射事件 可写的
// todo 使用者去调用发射 2
observableEmitter.onNext(9); // <? extends Integer> 不可写了 <? super Integer>可写
observableEmitter.onComplete();
}
})
// Observable<Integer>.subscribe
.subscribe(new Observer<Integer>() { // 下游
// 接口的实现方法
@Override
public void onSubscribe() {
// todo 1
Log.d(TAG, "已经订阅成功，即将开始发射 onSubscribe: ");
}
// 接口的实现方法
@Override
public void onNext(Integer item) {
// todo 3
Log.d(TAG, "下游接收事件 onNext: " + item);
}
// 接口的实现方法
@Override
public void onError(Throwable e) {
}
// 接口的实现方法
@Override
public void onComplete() {
// todo 4 最后一步
Log.d(TAG, "onComplete: 下游接收事件完成√√√√√√√√√√√√√√");
}
});
}
}
