Java 泛型

1. 概述

什么是java泛型？

泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。

泛型的本质

是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）

2、为什么需要泛型？

安全简单，可以将运行时错误提前到编译时错误。
在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率。

3. 特性

泛型只在编译阶段有效。看下面的代码：

（getClass() 返回此 Object 的运行时类。）

List<String> stringArrayList = new ArrayList<String>();
List<Integer> integerArrayList = new ArrayList<Integer>();

Class classStringArrayList = stringArrayList.getClass();
Class classIntegerArrayList = integerArrayList.getClass();

if(classStringArrayList.equals(classIntegerArrayList)){
    Log.d("泛型测试","类型相同");
}

输出结果：D/泛型测试: 类型相同。

通过上面的例子可以证明，在编译之后程序会采取去泛型化的措施。也就是说Java中的泛型，只在编译阶段有效。在编译过程中，正确检验泛型结果后，会将泛型的相关信息擦出，并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法。也就是说，泛型信息不会进入到运行时阶段。

4. 泛型的使用

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

4.1泛型类
泛型类型用于类的定义中，被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。

泛型类的最基本写法（不易理解，下面的例子中详解）：

class 类名称 <泛型标识：可以随便写任意标识号，标识指定的泛型的类型>{
  private 泛型标识 /*（成员变量类型）*/ var; 
  .....

  }
}

（1）一个最普通的泛型类：

此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型

对于常见的泛型模式，推荐的名称是：

K ——键，比如映射的键。

V ——值，比如 List 和 Set 的内容，或者 Map 中的值。

E ——异常类。

T ——泛型。

在实例化泛型类时，必须指定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）指定两个泛型类型

class Notepad<K,V>{       // 此处指定了两个泛型类型  
    private K key ;     // 此变量的类型由外部决定  
    private V value ;   // 此变量的类型由外部决定  
    public K getKey(){  
        return this.key ;  
    }  
    public V getValue(){  
        return this.value ;  
    }  
    public void setKey(K key){  
        this.key = key ;  
    }  
    public void setValue(V value){  
        this.value = value ;  
    }  
};  
public class GenericsDemo09{  
    public static void main(String args[]){  
        Notepad<String,Integer> t = null ;        // 定义两个泛型类型的对象  
        t = new Notepad<String,Integer>() ;       // 里面的key为String，value为Integer  
        t.setKey("汤姆") ;        // 设置第一个内容  
        t.setValue(20) ;            // 设置第二个内容  
        System.out.print("姓名；" + t.getKey()) ;      // 取得信息  
        System.out.print("，年龄；" + t.getValue()) ;       // 取得信息  
  
    }  
};  

//泛型的类型参数只能是类类型（包括自定义类），不能是简单类型

//传入的实参类型需与泛型的类型参数类型相同，即为Integer.
Generic<Integer> genericInteger = new Generic<Integer>(123456);

//传入的实参类型需与泛型的类型参数类型相同，即为String.
Generic<String> genericString = new Generic<String>("key_vlaue");

Log.d("泛型测试","key is " + genericInteger.getKey());
Log.d("泛型测试","key is " + genericString.getKey());

泛型测试: key is 123456
泛型测试: key is key_vlaue

定义的泛型类，就一定要传入泛型类型实参么？并不是这样，在使用泛型的时候如果传入泛型实参，则会根据传入的泛型实参做相应的限制，此时泛型才会起到本应起到的限制作用。如果不传入泛型类型实参的话，在泛型类中使用泛型的方法或成员变量定义的类型可以为任何的类型。

看一个例子：

Generic generic = new Generic("111111");
Generic generic1 = new Generic(4444);
Generic generic2 = new Generic(55.55);
Generic generic3 = new Generic(false);

Log.d("泛型测试","key is " + generic.getKey());
Log.d("泛型测试","key is " + generic1.getKey());
Log.d("泛型测试","key is " + generic2.getKey());
Log.d("泛型测试","key is " + generic3.getKey());

D/泛型测试: key is 111111
D/泛型测试: key is 4444
D/泛型测试: key is 55.55
D/泛型测试: key is false

注意：

泛型的类型参数只能是类类型，不能是简单类型。
不能对确切的泛型类型使用instanceof操作。如下面的操作是非法的，编译时会出错。

if(ex_num instanceof Generic<Number>){   
} 

4.3 泛型方法

泛型方法使得该方法能独立于类而产生变化。以下是一个基本的指导原则：无论何时，只要你能做到，你就应该尽量使用泛型方法。也就是说，如果使用泛型方法可以取代将整个类泛型化，那么就应该只使用泛型方法，因为它可以使事情更清楚明白。另外，对于一个static的方法而言，无法访问泛型类的类型参数。所以，如果static方法需要使用泛型能力，就必须使其成为泛型方法。

要定义泛型方法，只需将泛型参数列表置于返回值之前，就像下面这样：

代码示例

class Demo{  
    public <T> T fun(T t){            // 可以接收任意类型的数据  
        return t ;                  // 直接把参数返回  
    }  
};  
public class GenericsDemo26{  
    public static void main(String args[]){  
        Demo d = new Demo() ;   // 实例化Demo对象  
        String str = d.fun("汤姆") ; //   传递字符串  
        int i = d.fun(30) ;     // 传递数字，自动装箱  
        System.out.println(str) ;   // 输出内容  
        System.out.println(i) ;     // 输出内容  
    }  
};  

4.4 泛型接口
在泛型类的设计中，通常把泛型类共同要实现的方法的签名封装为泛型接口，然后在实现这些接口的泛型类中实现这些方法。泛型接口的声明语法和一般接口的声明语法一致，但需要在声明泛型的接口名称后加“<>”指定一个或者多个类型参数

例子：

//定义一个泛型接口

public interface Generator<T> {
    public T next();
}

（1）当实现泛型接口的类，未传入泛型实参时：

• 未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
• 即：class FruitGenerator implements Generator{
• 如果不声明泛型，如：class FruitGenerator implements Generator，编译器会报错：“Unknown class”

class FruitGenerator<T> implements Generator<T>{
    @Override
    public T next() {
        return null;
    }
}

（2）当实现泛型接口的类，传入泛型实参时：

• 传入泛型实参时：
• 定义一个生产器实现这个接口,虽然我们只创建了一个泛型接口Generator
• 但是我们可以为T传入无数个实参，形成无数种类型的Generator接口。
• 在实现类实现泛型接口时，如已将泛型类型传入实参类型，则所有使用泛型的地方都要替换成传入的实参类型
• 即：Generator，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)];
    }
}

4.4泛型通配符

1 默认情况下，没有约束条件的泛型类型参数（Sample）T 称为未绑定类型参数，当创建未绑定类型参
数的泛型类实例时，可以给参数类型指定任意类型。想要让泛型参数支持特定类型时，可以使用关键字 extends或者 super 关键字对泛型参数进行约束。
（1） extends 主要限定泛型参数的上界（常见的使用如下）：
<T extends 基类>：//T 只能是基类或者基类的派生类
<T extends 基接口>; //T 只能是实现基接口的派生类

//按照顺序排序
class Sort<T>{ <T extends Comparable<T>>
private T[] elem;
@SuppressWarnings("unchecked")
public Sort(){
elem=(T[])new Object[2];
}
public void swap(){ //这个方法是否书写正确？得到正确结果代码该如何进行修改？
if(elem[0]>elem[1]){
if(elem[0].compareTo(elem[1])>0){ ①
T temp=elem[0];
elem[0]=elem[1];
elem[1]=temp;
}
}
}

2 通配符 ? 解决当具体类型不确定的时候；当操作类型时，不需要使用类型的具体功能时，只使用Object类中的功能。那么可以用 ? 通配符来表未知类型。

Class<?>classType = Class.forName("java.lang.String");

（1）泛型限定（上限和下限）的表达式是怎样的？

上限：？extends E：可以接收E类型或者E的子类型对象。

下限：？super E：可以接收E类型或者E的父类型对象。

上限什么时候用：往集合中添加元素时，既可以添加E类型对象，又可以添加E的子类型对象。为什么？因为取的时候，E类型既可以接收E类对象，又可以接收E的子类型对象。

下限什么时候用：当从集合中获取元素进行操作的时候，可以用当前元素的类型接收，也可以用当前元素的父类型接收。