Java 泛型之 RxJava中的使用实例代码

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--------

福利

如果想要成为架构师或想突破20~30K薪资范畴，那就不要局限在编码，业务，要会选型、扩展，提升编程思维。此外，良好的职业规划也很重要，学习的习惯很重要，但是最重要的还是要能持之以恒，任何不能坚持落实的计划都是空谈。

若需要文中资料，直接扫码二维码免费领取↓↓↓

如果你没有方向，这里给大家分享一套由阿里高级架构师编写的《Android八大模块进阶笔记》，帮大家将杂乱、零散、碎片化的知识进行体系化的整理，让大家系统而高效地掌握Android开发的各个知识点。

相对于我们平时看的碎片化内容，这份笔记的知识点更系统化，更容易理解和记忆，是严格按照知识体系编排的。

全套视频资料：

一、面试合集

二、源码解析合集

三、开源框架合集

欢迎大家一键三连支持，若需要文中资料，直接扫码二维码免费领取↓↓↓