1，泛型概述
-
泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。
-
泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。
-
Java中的泛型，只在编译阶段有效。在编译过程中，正确检验泛型结果后，会将泛型的相关信息擦出，并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法。也就是说，泛型信息不会进入到运行时阶段.
-
泛型只能代表某种类型，不能 new
2，泛型使用
泛型有三种使用方式，分别为：泛型类、泛型接口、泛型方法。
2.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;
}
}
2.2 泛型接口
泛型接口与泛型类的定义及使用基本相同
//定义一个泛型接口
public interface Generator<T> {
public T next();
}
当实现泛型接口的类，未传入泛型实参时：
/**
* 未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
* 即：class FruitGenerator<T> implements Generator<T>{
* 如果不声明泛型，如：class FruitGenerator implements Generator<T>，编译器会报错："Unknown class"
*/
class FruitGenerator<T> implements Generator<T>{
@Override
public T next() {
return null;
}
}
当传入泛型参数时候：
/**
* 传入泛型实参时：
* 定义一个生产器实现这个接口,虽然我们只创建了一个泛型接口Generator<T>
* 但是我们可以为T传入无数个实参，形成无数种类型的Generator接口。
* 在实现类实现泛型接口时，如已将泛型类型传入实参类型，则所有使用泛型的地方都要替换成传入的实参类型
* 即：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.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;
}
泛型方法与可变参数
public <T> void printMsg( T s, T... args){
for(T t : args){
System.out.println(t);
}
}
静态方法如果要使用泛型，必须要额外声明泛型，即使在类上已经声明的泛型也不好使，也就是这个静态方法必须设置成泛型方法。
public class Dog<V> {
//普通方法可以使用类上的泛型
public V showV(V v){
System.out.println("普通方法");
return v;
}
//这个方法定义是错的，静态方法不能使用类声明的泛型
public static V showV1(V v){
System.out.println("静态方法");
return v;
}
//静态方法必须在方法上额外声明泛型才好使
public static <V> V showV1(V v){
System.out.println("静态方法");
return v;
}
}
3，泛型通配符 ?
我们知道Ingeter是Number的一个子类，同时在特性章节中我们也验证过Generic
我们使用Generic
public void showKeyValue1(Generic<Number> obj){
Log.d("泛型测试","key value is " + obj.getKey());
}
Generic<Integer> gInteger = new Generic<Integer>(123);
Generic<Number> gNumber = new Generic<Number>(456);
showKeyValue(gNumber);
// showKeyValue这个方法编译器会为我们报错：Generic<java.lang.Integer>
// cannot be applied to Generic<java.lang.Number>
// showKeyValue(gInteger);
通过提示信息我们可以看到Generic
回到上面的例子，如何解决上面的问题？总不能为了定义一个新的方法来处理Generic
public void showKeyValue1(Generic<?> obj){
Log.d("泛型测试","key value is " + obj.getKey());
}
可以解决当具体类型不确定的时候，这个通配符就是 ? ；当操作类型时，不需要使用类型的具体功能时，只使用Object类中的功能。那么可以用 ? 通配符来表未知类型。
4，泛型上下限
public class Test{
//传入的泛型必须是 Number 的子类
public static void showKeyValue1(Genertic<? extends Number> obj){
System.out.println("泛型测试: key value is " + obj.getKey());
}
//完全看不懂，什么玩意？
public static void showKeyValue2(Genertic<? super Number> obj){
System.out.println("泛型测试: key value is " + obj.getKey());
}
public static void main(String[] args) {
//这一行编译异常，因为 String 不是 Number 子类
//Genertic<String> generic1 = new Genertic<String>("11111");
Genertic<Integer> generic2 = new Genertic<>(2222);
Genertic<Float> generic3 = new Genertic<>(2.4f);
Genertic<Double> generic4 = new Genertic<>(2.56);
showKeyValue1(generic2);
showKeyValue1(generic3);
showKeyValue1(generic4);
}
}