RxJava系列之手写create操作符增加泛型限定

系列文章

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: 下游接收事件完成√√√√√√√√√√√√√√");
            }
        });
    }
}