RxJava系列之泛型高级

系列文章

RxJava系列之简介和观察者设计模式
RxJava系列之上游与下游
RxJava系列之常用创建型操作符
RxJava系列之常用变换操作符
RxJava系列之常用过滤操作符
RxJava系列之常用条件操作符
RxJava系列之常用合并操作符
RxJava系列之常用异常操作符
RxJava系列之线程切换实战
RxJava系列之背压模式
RxJava系列之配合Retrofit
RxJava系列之泛型高级
RxJava系列之手写create操作符
RxJava系列之手写create操作符增加泛型限定
RxJava系列之手写just操作符
RxJava系列之手写map操作符
RxJava系列之手写切换线程

因为RxJava中大量使用了泛型，而且使用了高级特性，所以这里学习一下。

泛型简单使用

 List<String> list = new ArrayList();
        list.add("A");
        // list.add(6); // 编译期 就可以看到错误
        String s = list.get(0);// 变量自动是String类型

上限和下限

继承关系，学生继承人，工人继承人，工人学生继承学生。

// todo 人类
public class Person {
}

// 学生 所属人类
public class Student extends Person {
}

// 工人 所属 人类
public class Worker extends Person {
}

public class WorkerStub extends Student {
}

public class Test<T> {

    private T t;

    public void add(T t) {
        this.t = t;
    }

    public T get() {
        return t;
    }

}

上限

 /**
     * extends 上限  Person or Person的所有子类 都可以， 最高的类型只能是Person，把最高的类型给限制住了
     * @param test
     * @param <T>
     */
    public static void show1(Test<? extends Person> test) {

    }

show1(new Test<Person>());
        show1(new Test<Student>());
        show1(new Test<Worker>());
        show1(new Test<WorkerStub>());

下限

/**
     * extends 下限  Student or Student 的所有父类 都可以  最低的类型只能是Student，把最低的类型给限制住了
     * @param test
     * @param <T>
     */
    public static void show2(Test<? super Student> test) {

    }

 // todo 下限
        // show2(new Test<WorkerStub>()); // 因为最低限制的子类 Student，不能在低
        show2(new Test<Student>());
        show2(new Test<Person>()); // 父类
        show2(new Test<Object>()); // 父类

读写模式

可读模式

 // todo 可读模式
        /*Test<? extends Person> test1 = null;
        test1.add(new Person()); // 不可写
        test1.add(new Student()); // 不可写
        test1.add(new Object()); // 不可写
        test1.add(new Worker()); // 不可写
        Person person = test1.get(); // 可读*/

可写模式

  // todo 可写模式  不完全可读
        Test<? super Person> test = null;
        test.add(new Person()); // 可写
        test.add(new Student()); // 可写
        test.add(new Worker()); // 可写

        Object object = test.get(); // 不完全可读

总结

由于RxJava大量的使用到了泛型，所有学习
如果我们不指定泛型类型，默认就是Object，Object的扩展集
1.? super F 下限：F or F 所有父类 都可以，所以属于把下面的类型限限制了，下面的类型不能低于F，不能是F的子类，否则编译不通过。
2.? extends F 上限：F or F 所有子类 都可以，所有属于把上面的类型给限制了，上面的类型不能高于F，不能是F的父类，否则编译不通过。
一句话记住（? super F: F 或者 F的所有父类 都可以， ? extends F: F 或者 F的所有子类都可以）
3.可写模式<？super F> 可写，不完全可读
4.可读模式<? extends F> 可读，不可写

上限，下限针对于方法的入参。
可读，可写针对于某个有泛型限定的变量