Java基础（一）-泛型

一、什么是泛型

泛型，即“参数化类型”。它把类型明确的工作推迟到创建对象或调用方法的时候。

二、泛型解决什么问题

在 Java SE 1.5 之前没有泛型的情况的下只能通过对类型 Object 的引用来实现参数的任意化，其带来的缺点是要做显式强制类型转换，而这种强制转换编译期是不做检查的，容易把问题留到运行时，而泛型在实现参数的任意化的同时还在编译时检查了类型安全。

三、泛型是如何工作的？什么是类型擦除？

泛型是通过类型擦除来实现的，编译器在编译时擦除了所有泛型类型相关的信息，所以在运行时不存在任何泛型类型相关的信息。泛型擦除具体来说就是在编译成字节码时首先进行类型检查，接着进行类型擦除（即所有类型参数都用他们的限定类型替换，包括类、变量和方法），接着如果类型擦除和多态性发生冲突时就在子类中生成桥方法解决，接着如果调用泛型方法的返回类型被擦除则在调用该方法时插入强制类型转换。

四、类型擦除和多态发生冲突是如何解决的？

Java泛型类型擦除以及类型擦除带来的问题
父类泛型类型被擦除后，有限定则变为限定类型，无限定则变为Object类型，这样，我们的本意是进行重写，实现多态。可是类型擦除后，只能变为了重载。为了解决这个问题虚拟机采用桥方法来解决此问题。具体细节可以看如上文章写得还挺详细的。

五、泛型的语法结构

泛型有三种使用方式，分别为：泛型类、泛型接口、泛型方法。
1）泛型类

//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时，必须指定T的具体类型
public class Generic<T>{ 
    //key这个成员变量的类型为T,T的类型由外部指定  
    private T key;
    public Generic(T key) { //泛型构造方法形参key的类型也为T，T的类型由外部指定
        this.key = key;
    }
    public T getKey(){ //泛型方法getKey的返回值类型为T，T的类型由外部指定
        return key;
    }
}
//传入的实参类型需与泛型的类型参数类型相同，即为String.
Generic<String> genericString = new Generic<String>("key_vlaue");

设置具体泛型类型则起到了参数类型限制作用，如果不设置则没限制。

2）泛型接口

//定义一个泛型接口
public interface Generator<T> {
    public T next();
}
未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
class FruitGenerator<T> implements Generator<T>{
    @Override
    public T next() {
        return null;
    }
}
传入泛型实参时，Generator<T>，public T next();中的的T都要替换成传入的String类型。
public class FruitGenerator implements Generator<String> {
    private String[] fruits = new String[]{"Apple", "Banana", "Pear"};
    @Override
    public String next() {
        Random rand = new Random();
        return fruits[rand.nextInt(3)];
    }
}

3）泛型方法

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

泛型方法和可变参数
public <T> void printMsg( T... args){
    for(T t : args){
        Log.d("泛型测试","t is " + t);
    }
}

静态方法与泛型
public class StaticGenerator<T> {
    ....
    ....
    /**
     * 如果在类中定义使用泛型的静态方法，需要添加额外的泛型声明（将这个方法定义成泛型方法）
     * 即使静态方法要使用泛型类中已经声明过的泛型也不可以。
     * 如：public static void show(T t){..},此时编译器会提示错误信息：
          "StaticGenerator cannot be refrenced from static context"
     */
    public static <T> void show(T t){
     ….
    }
}

六、泛型通配符

不同版本的泛型类实例是不兼容的，例如：Generic<Integer>不能被看作为`Generic<Number>的子类，为了满足这种情况，
引入通配符“？”。值得注意的是：’？’是类型实参，而不是类型形参。可以把”？“看成所有类型的父类。是一种真实的类型。

public void showKeyValue(Generic<?> obj){}

七、泛型的上下边界

在使用泛型的时候，我们还可以为传入的泛型类型实参进行上下边界的限制，如：类型实参只准传入某种类型的父类或某种类型的子类。
<? extends T>：是指 “上界通配符（Upper Bounds Wildcards）”
为泛型添加上边界，即传入的类型实参必须是指定类型的子类型

public static void test(List<? extends Number> list) { }

List集合装载的元素只能是Number的子类或自身
<? super T>：是指 “下界通配符（Lower Bounds Wildcards）”

public static void test(List<? super Number> list) { }

List集合装载的元素只能是Number的基类。

PECS原则（Producer Extends Consumer Super）

<? extends T> get有效。
<? super T> set有效。

另外再看看泛型边界用在泛型函数上的声明：

//在泛型方法中添加上下边界限制的时候，必须在权限声明与返回值之间的<T>上添加上下边界，即在泛型声明的时候添加
//public <T> T showKeyName(Generic<T extends Number> container)，编译器会报错："Unexpected bound"
public <T extends Number> T showKeyName(Generic<T> container){
    System.out.println("container key :" + container.getKey());
    T test = container.getKey();
    return test;
}

另外附上别人总结的泛型基础问题汇总：
https://www.cnblogs.com/huansky/p/8043149.html

参考文章：
https://blog.csdn.net/fangfengzhen115/article/details/78973258#comments
https://blog.csdn.net/u014224659/article/details/21539457
https://blog.csdn.net/s10461/article/details/53941091