泛型

（一）.  泛型

1.1 介绍

　　泛型是JDK5.0新增加的一个特性，泛型的本质是参数化类型，即所操作的数据类型都被指定为一个参数。这种类型参数可以用在类、接口、和方法的创建中，分别称为泛型类、泛型接口、泛型方法。Java语言引入泛型的好处是安全简单。

1.2 认识泛型

　　在JDK5.0之前，没有泛型的情况下，通过对类型Object的引用来实现参数的"任意化"，但"任意化"带来的缺点是需要显示的强制类型转换，此种转换要求开发者对实际参数类型预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不会提示错误，但在运行的时候会出现异常，这是一个安全隐患。

1.3 泛型的优势

　　使用泛型的优势在于编译期间检查类型，捕捉类型不匹配错误，并且所有的转换都是自动和隐式多的，提高代码复用率。

（二）.  泛型的使用　

2.1  泛型定义

　　实例化泛型类的语法结构如下：

  classname<type-param-list> obj = new classname<type-param-list> (cons-arg-list);  

　　泛型定义通常使用一个唯一的大写字母表示一个类型参数。

2.2  代码演示

//创建泛型类
public class Generic <T> {
    private T ob;//定义泛型成员变量
    public Generic(T ob){
        this.ob = ob;
    }
    public T getOb(){
        return ob;
    }
    public void setOb(T ob){
        this.ob = ob;
    }
    public void showType(){
        System.out.println("实际类型是：" + ob.getClass().getName());
    }
}

　　接下来创建类：

//创建测试类，用于解释泛型的使用方法
public class GenericDemo {
    public static void main(String[] args) {
        //定义泛型类Genneric的一个Integer版本
        Generic<Integer> intOb = new Generic<Integer>(88);
        intOb.showType();
        int i = intOb.getOb();
        System.out.println("value=" + i);
        System.out.println("---------------------------------");
        //定义泛型类Genneric的一个String版本
        Generic<String> strOb = new Generic<String>("Hello");
        strOb.showType();
        String s = strOb.getOb();
        System.out.println("value=" + s);
    }
}

　　运行结果：

实际类型是：java.lang.Integer
value=88
---------------------------------
实际类型是：java.lang.String
value=Hello

2.3  理解泛型需注意3点

• 泛型的类型参数是类类型（包括自定义类），不能是基本数据类。
• 同一种泛型可以对应多个版本（因为类型参数是不确定的），不同版本的泛型类实例是不兼容的。
• 泛型的类型参数可以有多个。

（三）.  有界类型

3.1  介绍

　　在有些时候需要对类型参数的取值进行一定程度的限制，以使数据具有可操作性。为了处理这种情况，Java提供了有界类型。在指定类型参数时可以使用extends关键字限制此类型参数代表的类必须继承自指定父类或父类本身。比如创建一个类：public class BoundGeneric<T extends Number>{}，BoundGeneric类的定义中，使用extends关键字将T的类型限制为Number类及其子类。

3.2  注意

　　在使用extends（如：T extends someClass）声明的泛型类进行实例化时，运行传递的类型参数是：如果someClass是类，可以传递someClass本身及其子类，如果someClass是接口，则可以传递实现接口的类。

3.3  通配符

　　通配符由”？“来表示，代表一个未知类型。

　　例如：public static void func（Generic <?> T）{}或者结合有界类型使用

　　　　　public static void func（Generic <? extends Number> T）

（四）.  泛型的局限

4.1 泛型的局限性

　　其实Java并没有真正的实现泛型，是编译器在编译的时候在字节码上了做手脚（成为擦除），这种实现理念造成java泛型本身有很多漏洞，局限性很大。其中大多数限制性是由类型擦除引起的。

• 泛型不能被实例化。但可以通过调用Class.newInstance和Array.newInstance方法，利用反射构造泛型对象和数组。
• 不能实例化泛型数组，即不能创建一个类型特定的泛型引用数组。如：Gen<String> []arrays = new Gen<String> [100];该语句是非法语句，因为会损害类型安全，但是如果使用通配符，就可以创建泛型类型的引用数组，如：Gen<?> []arrays = new Gen<?> [10];
• 不能用类型参数替换基本类型。因为擦除类型后原先的类型参数被Object或者限定类型替换，而基本类型是不能被对象所存储的，但是可以使用基本类型的包装类来解决此问题。
• 异常。不能抛出也不能捕获泛型类的异常对象，使用泛型类来扩展Throwable也是非法的。

public class GenericException <T> extends Exception{
    //泛型类无法继承Throwable,非法  
}

　　不能在catch子句中使用类型参数，如下面的方法将不能编译：

public static <T extends Throwable> void doWork(Class<T>  t){
    try {
    } catch (T e) {//不能捕获类型参数异常
    }
}

　　但是，在异常声明中可以使用类型参数。下面这个是合法的：

public static <T extends Throwable> void doWork(T t) throws T {
    try {
    } catch (Throwable realCause) {//不能捕获类型参数异常
        throw t;        
    }
}

• 静态成员。不能在静态变量或者静态方法中引用类型参数。如下述语句是非法的：

public class Gen<T>{
    //静态变量不能引用类型参数
    static T ob;
    //静态方法不能引用类型参数
    static T getOb(){
        return ob;
    }
}

　　尽管不能在静态变量或静态方法中引用类型参数，但可以声明静态泛型方法。

（五）.  技巧

　　当方法静态时，不能访问类上定义的泛型，如果静态方法使用泛型，只能将泛型定义在方法上，注意放置位置：public static <Y> void method(Y obj)

　　? extends E :接收E类型或者E的子类对象（（对于本身来说是）上限）

　　? super E  :接收E类型或者E的父类型（下限）

　　在集合存元素时，一般使用上限，因为这样取出都是按照上限类型来运算，不会出现安全隐患。

　　什么时候使用下限呢？

　　通常对集合中的元素进行取出操作时，可以用下限。