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