Java 泛型在RxJava 中的使用，网上有很多文章介绍，内容都差不多，不知道谁才是原创-_-
关键是给出的实例代码，都是不完整的，对于不好理解。
于是有了下文的自己写的完整代码。
(RxJava 是 观察者模式 的更高级的应用， 通过以下自定义的Observable 及其 map/ doOnNext操作，可以更好的理解RxJava框架的实现方式 )

1. 被观察的类 (对象)

仅是两个简单的Student 和 Teacher 类， 作用先不管

public class Student {
}

public class Teacher {
}

2.被观察者接口

2.1 将泛型声明放在接口或类

//将泛型声明放在接口
public interface Observable<T> {
    public T call();

    // 转换为另一类型R
    <R> Observable<R> map(Func1<T,R> fun1);

    // 下一步操作(链式调用)
    Observable<T> doOnNext(Action<T> action);
}

转换接口：

public interface Func1<T, R> {
    R call(T t);
}

链式调用

public interface Action <T>{
    void callAction(T t);
}

2.2 将泛型声明放在方法

//将泛型声明放在方法
public interface Observable2 {
    <T> T call(T t);
}

3.被观察者实现类

3.1 将泛型声明放在接口或类

//泛型声明在接口或类上,则类或接口中的方法均可使用T类型
public class ImplObservable<T> implements Observable<T> {
    T t;
    public ImplObservable(T t){
        this.t = t;
    }

    public static <T> ImplObservable<T> create (T t) {
        return new ImplObservable<>(t);
    }

    public ImplObservable(){
    }

    @Override
    public T call() {
        // TODO Auto-generated method stub
        System.out.println("ImplObservable call");
        return null;
    }

    //类型转换
    @Override
    public <R> Observable<R> map(Func1<T, R> fun1) {
        Observable<R> ob = ImplObservable.create(fun1.call(t));
        return ob;// 改变被观察着
    }

    //链式调用
    @Override
    public Observable<T> doOnNext(Action<T> action) {
        action.callAction(t);
        return this; // 被观察着不变
    }
}

3.2 将泛型声明放在方法

//泛型声明在方法上,则除去该声明有T泛型的方法之外,其他方法不识别T类型
public class ImplObservable2 implements Observable2{
    @Override
    public <T> T call(T t) {
        // TODO Auto-generated method stub
        System.out.println("ImplObservable2 call");
        return null;
    }
}

4. 测试代码

    public static void main(String args[]) {
        System.out.println("Hello RxJavaSample");
        //1. 将泛型声明在接口上或声明在类上
        System.out.println("------------RxJavaSample 1. 泛型类、接口 -------");
        Observable<Student> observer = new ImplObservable<Student>();
        Student student = observer.call();
        //2. 将泛型声明在方法上
        System.out.println("------------RxJavaSample 2. 泛型方法 -------");
        ImplObservable2 Observable2 = new ImplObservable2();
        Student student2 = Observable2.call(new Student());

        System.out.println("------------RxJavaSample 2-2. 泛型之构造函数的 类型安全 问题 -------");
        //3. 尝试向泛型在类上的 构造函数 传递 实际类型的 参数  (提示类型安全 警告??)
//        ImplObservable<Student> observable3 = new ImplObservable(new Student());
//        observable3.call();

        ImplObservable<Student> observable4 = ImplObservable.create(new Student());
        observable4.call();

        System.out.println("------------RxJavaSample 3. 类型转换 及 链式调用-------");
        Student student3 = new Student();
        Teacher teacher = new Teacher();
        ImplObservable.create(student3)
                .map(new Func1<Student, Teacher>() {
                    @Override
                    public Teacher call(Student student) {

                        System.out.println("student hashCode: " + student);
                        System.out.println("teacher hashCode: " + teacher);
                        return teacher;
                    }
                })
                .doOnNext(new Action<Teacher>() {
                    @Override
                    public void callAction(Teacher teacher) {
                        System.out.println("teacher hashCode: " + teacher);
                    }
                });
        System.out.println("------------RxJavaSample end--------");
    }

输出结果：

Hello RxJavaSample
------------RxJavaSample 1. 泛型类、接口 -------
ImplObservable call
------------RxJavaSample 2. 泛型方法 -------
ImplObservable2 call
------------RxJavaSample 2-2. 泛型之构造函数的 类型安全 问题 -------
ImplObservable call
------------RxJavaSample 3. 类型转换 及 链式调用-------
student hashCode: com.example.javalearnproject.Student@34ce8af7
teacher hashCode: com.example.javalearnproject.Teacher@b684286
teacher hashCode: com.example.javalearnproject.Teacher@b684286
------------RxJavaSample end--------

参考：
从RxJava中深入理解泛型,从学习泛型的过程中深入理解RxJava(一) - 简书 (jianshu.com)
如何深入理解Java泛型 - 知乎 (zhihu.com)