0.Java进阶学习之泛型

1. 什么是泛型?

泛型是Java SE 1.5的新特性.

"泛型"意味着编写的代码可以被不同类型的对象所重用. 泛型的本质是参数化类型.

也就是说,泛型是将所操作的数据类型作为参数的一种语法.

1.1 泛型类

泛型类和普通类的区别就是类名后有类型参数列表 <E>，既然叫“列表”了，当然这里的类型参数可以有多个，比如 public class HashMap<K, V>，参数名称由开发者决定。类名中声明参数类型后，内部成员、方法就可以使用这个参数类型，泛型类最常见的用途就是作为容纳不同类型数据的容器类，比如 Java 集合容器类

public class Paly<T>{
    T play(){}
}

其中T就是作为一个类型参数在Play被实例化的时候所传递来的参数, 比如:

Play<Integer> playInteger=new Play<>();

这里T就会被实例化为Integer,也就是

public class Paly<Integer>{
    Integer play(){}
}

1.2 泛型接口

//声明
public interface Comparator<T> {
    public int compare(T lhs, T rhs);
}
//使用
public class Generic implements GenericInterface<String>{
    //.......
}

1.3 泛型方法

泛型类，是在实例化类的时候指明泛型的具体类型；泛型类中的成员方法也都使用了泛型，按这些方法不是泛型方法,例如构造方法, 有的甚至泛型类中也包含着泛型方法. 泛型方法，是在调用方法的时候指明泛型的具体类型 。

/**
 * 泛型方法的基本介绍
 * @param tClass 传入的泛型实参
 * @return T 返回值为T类型
 * 说明：
 *     1）public 与 返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。
 *     2）只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
 *     3）<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
 *     4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。
 */
public <T> T genericMethod(Class<T> tClass)throws InstantiationException ,
  IllegalAccessException{
        T instance = tClass.newInstance();
        return instance;
}


Object obj = genericMethod(Class.forName("com.test.test"));

2.泛型的作用

2.1 使用泛型能写出更加灵活通用的代码

 泛型的设计主要参照了C++的模板, 旨在能让人写出更加通用化,更加灵活的代码.

2.2 泛型将代码安全性检查提前到编译期

泛型被加入Java语法中，还有一个最大的原因：解决容器的类型安全，使用泛型后，能让编译器在编译的时候借助传入的类型参数检查对容器的插入，获取操作是否合法，从而将运行时ClassCastException转移到编译时.

比如:

List dogs = new ArrayList();
dogs.add(new Cat());     

没有泛型之前，这种代码除非运行，否则你永远找不到它的错误。但是加入泛型后

List<Dog> dogs=new ArrayList<>();
dogs.add(new Cat());//Error Compile

会在编译的时候就检查出来。

2.3 泛型能够省去类型强制转换

在JDK1.5之前，Java容器都是通过将类型向上转型为Object类型来实现的，因此在从容器中取出来的时候需要手动的强制转换。

Dog dog=(Dog)dogs.get(1);

3.为什么要引入泛型?

在引入泛型之前，要想实现一个通用的、可以处理不同类型的方法，你需要使用 Object 作为属性和方法参数，比如这样：

public class Person {
    private Object[] mData;

    public Person(int size) {
        mData = new Object[size];
    }

    public Object getData(int index) {
        return mData[index];
    }

    public void add(int index, Object item) {
        mData[index] = item;
    }
   
    
public static void main(String[] argv){    
    Person person = new Person(10);
    person.add(0, new Teacher());
    person.add(1, new Student());
    //获取方法
    Teacher teacher = (Teacher)person.getData(0);
    // Teacher teacher = (Teacher)person.getData(1); 编译不会报错 只有在运行时候报错
    Student student = (Student)person.getData(1);
   }
}

使用 Object 来实现通用、不同类型的处理，有这么两个缺点：

1. 每次使用时都需要强制转换成想要的类型
2. 在编译时编译器并不知道类型转换是否正常，运行时才知道，不安全

在引入泛型之后

public class Person <T>{
    private T mData;
    public T getData() {
        return mData;
    }
    public void add(T item) {
        mData  = item;
    }
    public static void main(String[] argv){
        Person<Integer> person = new Person<>();
        person.add(11111111);
        Person<String> person1 =  new Person<>();
        person1.add("2222222");
        System.out.println(person.getData());
        System.out.println(person1.getData());
    }
}

4 通配符与嵌套

我们在定义泛型类,泛型方法,泛型接口的时候,通常碰到不同的通配符号,比如 T, E, K, V , ? 等等, 本质上这些都是通配符, 只不过是编码时的一种约定俗成的东西。比如上述代码中的 T，我们可以换成 A-Z 之间的任何一个 字母都可以，并不会影响程序的正常运行，但是如果换成其他的字母代替 T ，在可读性上可能会弱一些。

通常情况下，T，E，K，V，？是这样约定的：

• ？表示不确定的 java 类型
• T (type) 表示具体的一个java类型
• K V (key value) 分别代表java键值中的Key Value
• E (element) 代表Element

4.1 ?无界通配符

    已知:  有一个父类 Animal 和几个子类，如狗、猫等

    求解:  一个动物的列表

     答案 1 : 

List<Animal> listAnimals

     答案 2 :

List<? extends Animal> listAnimals

为什么要使用通配符而不是简单的泛型呢？

通配符其实在声明局部变量时是没有什么意义的，但是当你为一个方法声明一个参数时，它是非常重要的。

package generic;

import java.util.ArrayList;
import java.util.List;

public class GenericTest {
    static class Animal{
        public int legs = 4 ;
        public int countLegs(){
            return legs;
        }
    }
    static class Dog extends Animal{
        private int name;
        public int countLegs(){
            return legs;
        }
    }
    static int countLegs (List<? extends Animal > animals ) {
        int retVal = 0;
        for ( Animal animal : animals )
        {
            retVal += animal.countLegs();
        }
        return retVal;
    }

    static int countLegs1 (List<Animal> animals ){
        int retVal = 0;
        for ( Animal animal : animals )
        {
            retVal += animal.countLegs();
        }
        return retVal;
    }
    public static void main(String []args){
        List<Dog> dogs = new ArrayList<>();

        dogs.add(new Dog());
        // 不会报错
        System.out.println(countLegs(dogs));;
        // 报错
        System.out.println(countLegs1(dogs));;
    }
}

Error:(43, 39) java: 不兼容的类型: java.util.List<generic.GenericTest.Dog>无法转换为java.util.List<generic.GenericTest.Animal>

所以，对于不确定或者不关心实际要操作的类型，可以使用无限制通配符（尖括号里一个问号)，表示可以持有任何类型。像 countLegs 方法中，限定了上届，但是不关心具体类型是什么，所以对于传入的 Animal 的所有子类都可以支持，并且不会报错。而 countLegs1 就不行。

4.2 泛型上下边界

4.2.1 上界通配符  <? extends E>

上届：用 extends 关键字声明，表示参数化的类型可能是所指定的类型，或者是此类型的子类。在类型参数中使用 extends 表示这个泛型中的参数必须是 E 或者 E 的子类，这样有两个好处：

• 如果传入的类型不是 E 或者 E 的子类，编译不成功
• 泛型中可以使用 E 的方法，要不然还得强转成 E 才能使用

private <K extends A, E extends B> E test(K arg1, E arg2){

}

类型参数列表中如果有多个类型参数上限，用逗号分开

4.2.2 下界通配符  <? super E>

下界: 用 super 进行声明，表示参数化的类型可能是所指定的类型，或者是此类型的父类型，直至 Object

private <T> void test(List<? super T> dst, List<T> src){

}

public static void main(String[] args) {
    List<Dog> dogs = new ArrayList<>();
    List<Animal> animals = new ArrayList<>();

    test(animals,dogs);
}

4.2.3 通配符比较

两种有限制通配形式 < ? super E> 和 < ? extends E>

• < ? super E> 用于灵活写入或比较，使得对象可以写入父类型的容器，使得父类型的比较方法可以应用于子类对象。
• < ? extends E> 用于灵活读取，使得方法可以读取 E 或 E 的任意子类型的容器对象。

用《Effective Java》 中的一个短语来加深理解：

为了获得最大限度的灵活性，要在表示 生产者或者消费者 的输入参数上使用通配符，使用的规则就是：生产者有上限、消费者有下限：

PECS: producer-extends, costumer-super

因此使用通配符的基本原则：

• 如果参数化类型表示一个 T 的生产者，使用 < ? extends T>;
• 如果它表示一个 T 的消费者，就使用 < ? super T>；
• 如果既是生产又是消费，那使用通配符就没什么意义了，因为你需要的是精确的参数类型

小总结一下：

• T 的生产者的意思就是结果会返回 T，这就要求返回一个具体的类型，必须有上限才够具体；
• T 的消费者的意思是要操作 T，这就要求操作的容器要够大，所以容器需要是 T 的父类，即 super T；

   private  <E extends Comparable<? super E>> E max(List<? extends E> e1){
        if (e1 == null){
            return null;
        }
        //迭代器返回的元素属于 E 的某个子类型
        Iterator<? extends E> iterator = e1.iterator();
        E result = iterator.next();
        while (iterator.hasNext()){
            E next = iterator.next();
            if (next.compareTo(result) > 0){
                result = next;
            }
        }
        return result;
    }

上述代码中的类型参数 E 的范围是 <E extends Comparable<? super E>>，我们可以分步查看：

1. 要进行比较，所以 E 需要是可比较的类，因此需要 extends Comparable<…>（注意这里不要和继承的 extends 搞混了，不一样）
2. Comparable< ? super E> 要对 E 进行比较，即 E 的消费者，所以需要用 super
3. 而参数 List< ? extends E> 表示要操作的数据是 E 的子类的列表，指定上限，这样容器才够大

5.泛型的类型擦除

Java 中的泛型和 C++ 中的模板有一个很大的不同：

• C++ 中模板的实例化会为每一种类型都产生一套不同的代码，这就是所谓的代码膨胀。
• Java 中并不会产生这个问题。虚拟机中并没有泛型类型对象，所有的对象都是普通类。

在 Java 中，泛型是 Java 编译器的概念，用泛型编写的 Java 程序和普通的 Java 程序基本相同，只是多了一些参数化的类型同时少了一些类型转换。

实际上泛型程序也是首先被转化成一般的、不带泛型的 Java 程序后再进行处理的，编译器自动完成了从 Generic Java 到普通

Java 的翻译，Java 虚拟机运行时对泛型基本一无所知。

当编译器对带有泛型的java代码进行编译时，它会去执行类型检查和类型推断，然后生成普通的不带泛型的字节码，这种普通的

字节码可以被一般的 Java 虚拟机接收并执行，这在就叫做 类型擦除（type erasure）。

实际上无论你是否使用泛型，集合框架中存放对象的数据类型都是 Object，这一点不仅仅从源码中可以看到，通过反射也可以

看到。

List<String> strings = new ArrayList<>();
List<Integer> integers = new ArrayList<>();
System.out.println(strings.getClass() == integers.getClass());//true

上面代码输出结果并不是预期的 false，而是 true。其原因就是泛型的擦除。

擦除的实现原理

Java 编译器在编译期间擦除了泛型的信息，那运行中怎么保证添加、取出的类型就是擦除前声明的呢？

Java 编辑器会将泛型代码中的类型完全擦除，使其变成原始类型。当然，这时的代码类型和我们想要的还有距离，接着 Java 编译器会在这些代码中加入类型转换，将原始类型转换成想要的类型.这些操作都是编译器后台进行，可以保证类型安全。总之泛型就是一个语法糖，它运行时没有存储任何类型信息。

擦除导致的泛型不可变性

泛型中没有逻辑上的父子关系，如 List 并不是 List 的父类。两者擦除之后都是List，所以形如下面的代码，编译器会报错：

/**
 * 两者并不是方法的重载。擦除之后都是同一方法，所以编译不会通过。
 * 擦除之后：
 * 
 * void m(List numbers){}
 * void m(List strings){} //编译不通过，已经存在相同方法签名
 */
void method(List<Object> numbers) {

}

void method(List<String> strings) {

}

泛型的这种情况称为 不可变性，与之对应的概念是 协变、逆变：

• 协变：如果 A 是 B 的父类，并且 A 的容器（比如 List< A>） 也是 B 的容器（List< B>）的父类，则称之为协变的（父子关系保持一致）
• 逆变：如果 A 是 B 的父类，但是 A 的容器 是 B 的容器的子类，则称之为逆变（放入容器就篡位了）
• 不可变：不论 A B 有什么关系，A 的容器和 B 的容器都没有父子关系，称之为不可变

Java 中数组是协变的，泛型是不可变的。

如果想要让某个泛型类具有协变性，就需要用到边界。

擦除的拯救者：边界

泛型运行时被擦除成原始类型，这使得很多操作无法进行.

如果没有指明边界，类型参数将被擦除为 Object。

如果我们想要让参数保留一个边界也就是上下界，可以给参数设置一个边界，泛型参数将会被擦除到它的第一个边界（边界可以有多个），这样即使运行时擦除后也会有范围。

public class GenericErasure {
    interface Game {
        void play();
    }
    interface Program{
        void code();
    }

    public static class People<T extends Program & Game>{
        private T mPeople;

        public People(T people){
            mPeople = people;
        }

        public void habit(){
            mPeople.code();
            mPeople.play();
        }
    }
}

上述代码中, People 的类型参数 T 有两个边界,编译器事实上会把类型参数替换为它的第一个边界的类型。

泛型的规则

• 泛型的参数类型只能是类（包括自定义类），不能是简单类型。
• 同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。
• 泛型的类型参数可以有多个
• 泛型的参数类型可以使用 extends 语句，习惯上称为“有界类型”
• 泛型的参数类型还可以是通配符类型，例如 Class+

泛型的使用场景

当类中要操作的引用数据类型不确定的时候，过去使用 Object 来完成扩展，JDK 1.5后推荐使用泛型来完成扩展，同时保证安全性。

总结

1.上面说到使用 Object 来达到复用，会失去泛型在安全性和直观表达性上的优势，那为什么 ArrayList 等源码中的还能看到使用 Object 作为类型？

根据《Effective Java》中所述，这里涉及到一个 “移植兼容性”：

泛型出现时，Java 平台即将进入它的第二个十年，在此之前已经存在了大量没有使用泛型的 Java 代码。人们认为让这些代码全部保持合法，并且能够与使用泛型的新代码互用，非常重要。

这样都是为了兼容，新代码里要使用泛型而不是原始类型。

2.泛型是通过擦除来实现的。因此泛型只在编译时强化它的类型信息，而在运行时丢弃(或者擦除)它的元素类型信息。擦除使得使用泛型的代码可以和没有使用泛型的代码随意互用。

3.如果类型参数在方法声明中只出现一次，可以用通配符代替它。

比如下面的 swap 方法，用于交换指定 List 中的两个位置的元素：

private <E> void swap(List<E> list, int i, int j) {
    //...
}

• 1
• 2
• 3

只出现了一次 类型参数，没有必要声明，完全可以用通配符代替：

private void swap(List<?> list, int i, int j){
    //...
}

• 1
• 2
• 3

对比一下，第二种更加简单清晰吧。

4.数组中不能使用泛型

这可能是 Java 泛型面试题中最简单的一个了，当然前提是你要知道 Array 事实上并不支持泛型，这也是为什么 Joshua Bloch 在 《Effective Java》一书中建议使用 List 来代替 Array，因为 List 可以提供编译期的类型安全保证，而 Array 却不能。

5.Java 中 List<Object> 和原始类型 List 之间的区别?

原始类型和带参数类型 之间的主要区别是：

• 在编译时编译器不会对原始类型进行类型安全检查，却会对带参数的类型进行检查
• 通过使用 Object 作为类型，可以告知编译器该方法可以接受任何类型的对象，比如String 或 Integer
• 你可以把任何带参数的类型传递给原始类型 List，但却不能把 List< String> 传递给接受 List< Object> 的方法，因为泛型的不可变性，会产生编译错误。

这道题的考察点在于对泛型中原始类型的正确理解

RxJava中泛型的使用分析