Java泛型

• 一、入门泛型的基本应用
• 二、泛型的通配符扩展
• 三、自定义泛型方法
• 四、自定义泛型类
• 五、通配符?和T的区别

一、入门泛型的基本应用

　　1). Jdk1.5的新特性。

　　2). jdk1.5之前的集合操作存在的问题

　　/**
     * jdk1.5之前的集合操作的问题
     */
    @Test
    public void test(){
        ArrayList collection = new ArrayList();
        collection.add(1);
        collection.add(1L);
        collection.add("abc");
        
        int i = (Integer) collection.get(1);
    }

　　报错：java.lang.ClassCastException: java.lang.Long cannot be cast to java.lang.Integer

　　没引入泛型之前，集合中的各种元素存在于程序员的脑子中，类型的转换也完全由程序员来决定，那么此时编译器在编译代码的过程中完全相信程序员是正确的，但是在运行的时候就暴露出错误来了。那么怎么解决这种问题呢？在jdk1.5引入泛型之后，在定义集合类的时候，明确表示集合中应该是什么类型的元素，这样通过知道使用泛型定义的变量的类型限制，编译器可以在一个高得多的程度上验证类型假设，这样在编译的过程中如果没有在集合中放入相对应类型的元素，编译器就会报错，从而增强了程序的健壮性、安全性和灵活性。

　　引入泛型后的代码如下：

　　/**
     * 引入泛型之后的集合操作
     */
    @Test
    public void test2(){
        ArrayList<Integer> collection = new ArrayList<Integer>();
        collection.add(1);
        /*collection.add(1L);
        collection.add("abc");*///这两行代码编译时，编译器就报告了语法错误。
        int i = collection.get(0);//因为使用了泛型，此时编译器知道每个元素都是int类型的，所以不需要再进行类型转换
    }

　　3).泛型是给javac编译器使用的，在编写和编译源码的时候就能防止可能错误的代码的输入，从而提高程序的健壮性。

　　4).为了运行效率不受影响，编译器在将源码编译成Class字节码文件的时候，会将类型信息去掉（去类型化），所以对于参数化的泛型类型，getClass()返回的字节码对象和原始类型的字节码对象一样。如下示例所示：

　　/**
     * 编译去类型化
     */
    @Test
    public void test3(){
        System.out.println(new ArrayList<Integer>().getClass().getName());
        System.out.println(new ArrayList<String>().getClass().getName());
        System.out.println(new ArrayList<Integer>().getClass() == ArrayList.class);
    }

　　结果：
    java.util.ArrayList
　　java.util.ArrayList
　　true

　　5).由于使用泛型和不使用泛型的类型，编译生成的字节码对象去掉了泛型的类型信息，所以只要想法跳过编译器，就可以在泛型集合中加入其他类型的数据。方法是使用反射机制，通过字节码对象来动态添加。如下所示：

　　/**
     * 跳过编译器检查，使用反射添加非泛型集合类型的其他类型数据
     * @throws SecurityException 
     * @throws NoSuchMethodException 
     * @throws InvocationTargetException 
     * @throws IllegalArgumentException 
     * @throws IllegalAccessException 
     */
    @Test
    public void test4() throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException{
        ArrayList<Integer> collection = new ArrayList<Integer>();
        collection.add(1);
        Class<? extends ArrayList> clazz = collection.getClass();
        clazz.getMethod("add", Object.class).invoke(collection, "abc");
        
        System.out.println(collection.get(1));
    }

　　6).在JDK 1.5+中，你还可以按原来的方式将各种不同类型的数据装到一个集合中，但编译器会报告unchecked警告。

　　7).泛型涉及的相关术语

　　　　比如：ArrayList<E>类定义和ArrayList<Integer>类引用中涉及如下术语：

　　　　a. 整个称为ArrayList<E>泛型类型

　　　　b. ArrayList<E>中的E称为类型变量或类型参数

　　　　c. 整个ArrayList<Integer>称为参数化的类型

　　　　d. ArrayList<Integer>中的Integer称为类型参数的实例或实际类型参数

　　　　e. ArrayList<Integer>中的<>念 Arraylist typeof Integer

　　　　f. ArrayList称为原始类型

　　  8). 参数化类型与原始类型的兼容性

　　　　　a. 参数化类型可以引用一个原始类型的对象，编译报告警告，例如:

　　　　　　　Collection<String> c = new Vector();

　　　　　b. 原始类型可以引用一个参数化类型的对象，编译报告警告，例如:

　　　　　　　 Collection c = new Vector<String>();//原来的方法接受一个集合参数，新的类型也要能传进去。

　　　9). 参数化类型不考虑类型参数的继承关系：即参数化类型之间不存在继承关系　

　　　　Vector<String> v  =  new Vector<Object>(); //错误!

　　　　对于编译器来说，一个类型参数是Object的参数化类型（可以看作是一种具体的类型）赋值给一个类型参数是String的参数化类型（可以看作是一种具体的类型），那么这       个集合到底是存储哪种类型呢？只有参数类型一致了，才能说明这两种参数化类型是对等的，不存在继承关系的。

　　　　Vector<Object> v = new Vector<String>(); //也是错误的!

　　　　假设Vector<String> v = new Vector<Object>();可以的话，那么以后从v中取出的对象当作String用，而v实际指向的对象中可以加入任意的类型对象；假设　　　　       Vector<Object> v = new Vector<String>();可以的话，那么以后可以向v中加入任意的类型对象，而v实际指向的集合中只能装String类型的对象。

　　虽然参数化类型之间不存在继承关系，但是集合中的元素是存在继承关系的（多态）：

　　　　Collection<Object> cols = new Arraylist<Object>();

　　　　Cols.add(“abc”);  //正确的。

　　10). 编译器不允许创建泛型变量的数组。即在创建数组实例时，数组的元素不能使用参数化的类型，例如，下面语句有错误：

          Vector<Integer> vectorList[] = new Vector<Integer>[10];

　　 11). 思考题，如下会报错么？

　　　　Vector v1 = new Vector<String>();

　　　　Vector<Object> v = v1;

           编译器是一行一行编译的，第一行代码根据参数化类型和原始类型的兼容性，编译通过。

           第二行也是根据参数化类型和原始类型的兼容性，编译通过。

           会不会发生错误是在编译阶段的编译器说了算，如果把两行当一行思考，就成运行阶段了。

二、泛型的通配符扩展

　　　参考《泛型的通配符扩展》

三、自定义泛型方法

 　　1). Java中的泛型类型（或者泛型）类似于 C++ 中的模板。但是这种相似性仅限于表面，Java 语言中的泛型基本上完全是在编译器中实现，用于编译器执行类型检查和类型         推断，然后生成普通的非泛型的字节码，这种实现技术称为擦除（erasure）（编译器使用泛型类型信息保证类型安全，然后在生成字节码之前将其清除）。这是因为扩展虚           拟机指令集来支持泛型被认为是无法接受的，这会为 Java 厂商升级其 JVM 造成难以逾越的障碍。所以，java的泛型采用了可以完全在编译器中实现的擦除方法。

         java中的如下代码无法通过编译：

　　/**
     * 模仿c++的泛型，但是编译不通过
     */
    public static <T> T add(T x, T y){
        return x+y;
    }

　　因为不一定所有的类型都有“+”操作。

　　2). 定义java泛型方法：

　　   用于放置泛型的类型参数的尖括号应出现在方法的其他所有修饰符之后和在方法的返回类型之前，也就是紧邻返回值之前。按照惯例，类型参数通常用单个大写字母表示。比         如：

　　public static <T> T add(T x, T y){
        return y;
　　}

　　@Test
    public void test8(){
        int i = add(1,2);
        Number j = add(3.5, 1);
        Object o = add(2, "abc");
    }   

　　以上涉及泛型方法的类型推断：

      Number j = add(3.5, 1);

      其中3.5是float，1是int ，那么他们共同的类型是Number

      Object o = add(2, "abc");

      其中2是int，’abc’是String ，那么他们共同的类型是Object

　　3). 交换数组中的两个元素的位置的泛型方法语法定义如下：

　　/**
     * 交换数组中两个元素的位置的泛型方法
     */
    public static <T> void swap(T[] a,int i,int j){
        T t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
    
    @Test
    public void test7(){
        String[] strs = new String[]{"a","b","c"};
        swap(strs, 1, 2);
        
        int[] ins = new int[]{1,2,3,4,5};
        //编译不通过
        //swap(ins, 1, 2);
    }

　　　　int[] ins = new int[]{1,2,3,4,5};

　　　　//编译不通过

　　　　//swap(ins, 1, 2);

　　　　编译不通过的原因:

     　　只有引用类型才能作为泛型方法的实际参数，对于第一条测试的add方法，使用基本类型的数据进行测试没有问题，这是因为自动装箱和拆箱了。 swap(ins,1，2);语        句会报告编译错误，这是因为编译器不会对ins中的int自动拆箱和装箱了，因为ins本身已经是对象了，你想要的有可能就是int数组呢？它装箱岂不弄巧成拙了。

　　4）除了在应用泛型时可以使用extends限定符，在定义泛型时也可以使用extends限定符，例如，Class.getAnnotation()方法的定义。并且可以用&来指定多个边界，如<V 　　extends Serializable & cloneable> void method(){}。比如JavaAPI中的getAnnotation方法。

　　　　

　　　　A类型只能是Annotation及其子类。

　　 5).普通方法、构造方法和静态方法中都可以使用泛型。

　　 6). 也可以用类型变量表示异常，称为参数化的异常，可以用于方法的throws列表中，但是不能用于catch子句中。　

　　/**
     * 泛型参数化异常
     * @throws T
     */
    private static <T extends Exception> void sayHello() throws T {
        try {

        } catch (Exception e) {
            throw (T) e;
        }
    }

　　 7). 在泛型中可以同时有多个类型参数，在定义它们的尖括号中用逗号分，例如：

　　　　public static <K,V> V getValue(K key) { return map.get(key);}

四、自定义泛型类

　　1).为什么需要泛型类

　　　 定义一个类GenericDao1

　　public class GenericDao1 {
　　　
       //自定义泛型方法
   　　 public <T> void add(T obj){
    　　}
       
       //自定义泛型方法
    　　public <T> T getById(int id){
        　　return null;
    　　}
　　}

　　 测试：

　　/**
     * 使用自定义泛型方法的缺点
     */
    @Test
    public void test9(){
        GenericDao1 dao = new GenericDao1();
        dao.add(new Person());
        String id = dao.getById(1);
    }

　　　对于一个dao来说，应该是所有方法围绕着一个类型的pojo对象，根据传入的pojo对象类型决定不同的pojo类型，但是上述自定义add泛型方法和getByid泛型方法在定义的     时候返回的都是T，但是在使用的时候，彼此之间根本没有约束，分别在对应方法调用的时候来决定T的类型。为了实现GenericDao1类中所有的方法都是围绕同一个pojo类     型，需要定义泛型类。

　　2). 泛型类的定义

public class GenericDao<T> {
    public void save(T t) {
    }
    public void delete(int id) {
    }
    public void update(T t) {
    }
    public T findById(int id) {
        return null;
    }
    public Set<T> findByConditions(String conditions) {
        return null;
    }
}

　　 测试：

    @Test
    public void test10(){
        GenericDao<Person> dao = new GenericDao<Person>();
        dao.save(new Person());
        Person p = dao.findById(1);
    }

　　　当在初始化GenericDao的时候指定T的类型，那么GenericDao类中的所有非静态方法中的T都是此类型。

　　3). 注意点　

　　　 a).  在对泛型类型进行参数化时，类型参数的实例必须是引用类型，不能是基本类型。

         b).  泛型类，是在实例化类的时候指明泛型的具体类型；泛型方法，是在调用方法的时候指明泛型的具体类型。

         c).   当一个类被声明为泛型时，只能被实例变量、方法和内部类调用，而不能被静态变量和静态方法调用。因为静态成员是被通过类调用的，不需要实例化，所以也                  就不能确定T的实际类型了，比如GenericDao类型如果不是实例化的话，T就不能确定到底是什么类型了。

       /**
        * 静态成员是通过了类调用的，不实例化类，无法确定T的实际类型
        * 这个方法放在泛型类中会报错， 
        */
        /*public static void testStatic(T t){
        
        }*/

　　　      如果一定要使用泛型的话，可以将静态方法改成泛型方法，泛型方法是在方法调用的时候，根据传入的参数来决定T的实际类型。

        /**
         * 如果非要使用泛型的话，可以将静态方法改成泛型方法，泛型方法是在方法调用的时候，
         * 根据传入的参数来决定T的实际类型
         */
         public static <T> void testStatic2(T t){ 
        }

　　 　d). 使用泛型类和泛型方法增强了代码的健壮性和灵活性。

　　4.  问题：类中只有一个方法需要使用泛型，是使用类级别的泛型，还是使用方法级别的泛型？

    　　使用方法级别的。

五、通配符?和T的区别

　　  是java泛型的两种用法：List<T>是泛型方法，List<?>是限制通配符

　　 ？ 代表一种位置类型，而T是在自定义泛型的时候会根据实例化对象的时候给T传入一个参数类型，此时T就是一种固定的类型，此时在这个泛型类中，所有的非静态方法中的T都是实例化时传入的那个参数的类型，比如：

public class GenericDao<T> {
    public void save(T t) {
    }

    public void delete(int id) {
    }

    public void update(T t) {
    }

    public T findById(int id) {
        return null;
    }

    public Set<T> findByConditions(String conditions) {
        return null;
    }
    
    /**
     * 静态成员是通过了类调用的，不实例化类，无法确定T的实际类型
     */
    /*public static void testStatic(T t){
        
    }*/
    
    /**
     * 如果非要使用泛型的话，可以将静态方法改成泛型方法，泛型方法是在方法调用的时候，
     * 根据传入的参数来决定T的实际类型
     */
    public static <T> void testStatic2(T t){
        
    }
}　

　　@Test
    public void test10() {
        GenericDao<Person> dao = new GenericDao<Person>();
        dao.save(new Person());
        Person p = dao.findById(1);
    }

除了testStatic2方法中的T，其余的T都是实例化GenericDao时传入的Person类型。

例如Class类：

对于？，比如forName方法：

public static Class<?> forName(String className) throws ClassNotFoundException

因为不知道返回是那种类型的Class对象，所以用?来表示

比如：public T newInstance() throws InstantiationException, IllegalAccessException

在Class实例化后，已经知道了Class类中的T代表了那种Class类型，那么此时返回的就是T类型的实例对象。

　　@Test
    public void test11() throws ClassNotFoundException, InstantiationException, IllegalAccessException{
        Class<?> claszz = Class.forName("java.lang.String");
        Object s = claszz.newInstance();

        Class<String> c = String.class;
        String str = c.newInstance();
    }

参考文章：

　　　　1.http://www.cnblogs.com/iyangyuan/archive/2013/04/09/3011274.html

　　　　2.http://zhidao.baidu.com/link?url=jQMPmgEBj1ixHhp52XwcllWJHlsFpKtxOB94LWtG1zkF9A34nX-xP71Pc2ao1ityHLHt9tNXw8I8XLiEdA2yYq

　　　　3.http://825635381.iteye.com/blog/2017650

　　　　4.https://www.zhihu.com/question/31429113