泛型全面分析和应用（一）

       概述

       Java SE5的重大变化之一就是提出了泛型的概念。泛型实现了参数化类型的概念，使代码可以应用于多种类型中。有很多原因促成了泛型的出现，而最主要的原因，就是为了构建容器类。我们很多时候在写代码的过程中，经常是遇到了同一个方法如果传入或者传出的参数类型过于单一，同样的功能的方法我们要写两次甚至是多次，原因就是由于参数类型不能适应其他类型的应用。那么为了解决这个问题，Java设计者也是煞费苦心。

• 一个泛型的小例子
• 泛型中使用注意的方法特性
• 擦除与其解决方法
• 泛型技术实例

一、一个泛型的小例子

---

      在Java SE5之前，为了写一个通用的方法，也许得这样子。用Object来作为一个标准，反正大家都是Object的子类。

package Generic;

public class Holder {

    private Object a;
    public Holder(Object a){
        this.a = a;
    }
    public void set(Object a){
        this.a = a;
    }
    public Object get(){
        return a;
    }
    public static void main(String args[]){
        Holder h1 = new Holder(new String());
        h1.set("ss");
        Holder h2 = new Holder(new Integer(1));
        h2.set(“asdf”);
    }
}

       大家发现这个问题没有，既然Hodler h2的set方法的传入参数是一个Object，那么这个参数就可以是String，Integer，Double，h2其实是想保存的一个Integer类型的数据，但由于Object的泛用性，导致了一个String类型的数据保存了进去。这么来说，这就是一个潜在的隐患了。

       在有些情况下，我们确实希望容器能够同时持有多种类型的对象。但是，通常来说，我们只会使用容器来存储一种类型的对象。泛型的主要目的之一就是用来指定容器要持有什么类型的对象，而且有编译器来保证类型的正确性。因此，与其使用Object，我们更喜欢暂时不指定类型，而是稍后再决定具体使用什么类型。要达到这个目的，需要使用类型参数，用尖括号括住，放在类名后面。然后在使用这个类的时候，再用实际的类型代替此类型参数。

package Generic;

public class Holder2<T> {

    private T a;
    public Holder2(T a){
        this.a = a;
    }
    public void set(T a){
        this.a = a;
    }
    public T get(){
        return a;
    }15 }

二、泛型中使用注意的方法特性

---

      由于Object的包容性，导致了参数可能的混乱。所以为了解决这个问题，泛型的提出是一个很好的方案。下面就来介绍下泛型的一些用法和特点，这些特性大都由于泛型的擦除机制所导致，擦除机制是指在运行过程中任何和类型有关的信息都会被擦除，所有在运行中集合的具体信息都被擦除成它们的原生类型。下面通过一个例子来了解：

public class TestF {

    public static void main(String[] args) {
        Class a1 = new ArrayList<Integer>().getClass();
        Class a2 = new ArrayList<String>().getClass();
        System.out.println(a1 == a2);
       //结果是true
    }

}

      ArrayList<Integer>和ArrayList<String>的class其实在擦除后都是ArrayList。

1.不能有继承的关系泛型的

Vector<Object> v = new Vector<String>(); 
//Type mismatch: cannot convert from Vector<String> to Vector<Object>

     

       不能有继承的关系泛型。声明了一个Vector<Object>与Vector<String>这对组合和Object与String这对组合是完全不同的。Object和String这对的确有关系，Object是String的父类，从java的多态Object obj = new String()这个语句是没有关系的。但是Vector<Object>和Vector<String>的组合就不是继承关系，在编译时，其实、Vector<Object> v =new Vector<String>实际上是Vector c = new Vector()这种效果，其实就是java泛型的擦除效果。

      其实从另外一个角度去看，Vector<Object>其实就是告诉编译器，Vector里面要放的是Object，但是在实例化的时候却放入了String，虽然是继承关系，但是还是不同的两个class。当涉及到了集合，看问题的角度提升到 集合 的层面去观察，里面的泛型类型就一定要一致了（在没有使用通配符？的情况下要一致，使用了？后面详细讲）。

2.不能有声明数组类型的泛型

         为什么不能有声明数组类型的泛型呢？我看了一下Java SE的官方文档 http://docs.oracle.com/javase/tutorial/extra/generics/fineprint.html
         里面有两段代码很清楚的阐释了这个问题。

// Not really allowed.
List<String>[] lsa = new List<String>[10];
Object o = lsa;
Object[] oa = (Object[]) o;
List<Integer> li = new ArrayList<Integer>();
li.add(new Integer(3));
// Unsound, but passes run time store check
oa[1] = li;

// Run-time error: ClassCastException.
String s = lsa[1].get(0);

      假设泛型数组允许被建立，如果此时有一个List<String>的数组，但是经过一系类转换后，居然把List<Integer>给赋给了 List<String>数组，这是明显的错误，但是由于java泛型的擦除机制，程序代码没有报错，此时已经有问题了。

       解决这个问题，就是不要声明数组类型的泛型，用通配符声明。

// OK, array of unbounded wildcard type.
List<?>[] lsa = new List<?>[10];
Object o = lsa;
Object[] oa = (Object[]) o;
List<Integer> li = new ArrayList<Integer>();
li.add(new Integer(3));
// Correct.
oa[1] = li;
// Run time error, but cast is explicit.
String s = (String) lsa[1].get(0);

        由于通配符，程序一开始不知道List<?>具体是什么类型的的数组，这个时候我们将List<Integer>放入进去，编译器还好能接受。最后一句，故意从List<Integer>去拿String，这是报了java.lang.ClassCastException的错误。

3.泛型类不能有static修饰方法

      这个更加不用说了，泛型编译后其实是擦除了很多信息，很多时候都没有确定好参数类型，到了运行调用的时候才进行的添加的。而static是静态关键字，被修饰的变量和方法都是在运行一开始就被加载到了虚拟机中，无需要再new对象，一直通过对象引用就好了。这两种状态是不一致的，所以不能在泛型类上面加上static。

4.泛型参数会由于参数的合集类型、个数、顺序一样而导致方法不能重载。

    public static void applyVecotr(Vector<Integer> v,Integer i){
        //泛型里的参数是不能作为区分参数去overload（重载）
    }
    public static void applyVecotr(Vector<String> v,Integer i){
        //泛型里的参数是不能作为区分参数去overload（重载）
    }

      此时报错 Erasure of method applyVecotr(Vector<Integer>, Integer) is the same as another method in type GenericTest

5.通配符？和泛型类型参数代表符号<T>、<K>、<V>等的关系和区别

     在一个代码中通配符？用于泛型代表任何的类型，而<T>、<K>、<V>也是一样功能。但是<T>、<K>、<V>等符号有一个好处，就是可以运用到在整个方法甚至整个类中去，用来区分多个泛型。表示<T>所代表的符号都是同一个类型的参数，而<K>是另外的一种参数。但是对于泛型参数则需要在方法或者类的开头声明，而通配符？则不需要的。

public class DiffGenericParameter<K,V> {
    
    private K k;//代表K为key值
    private V v;//代表V为value值
    public DiffGenericParameter(K k,V v){
        this.v = v;
        this.k = k;
    };
}

 

三、擦除与其解决方法

---

      在《java编程思想》中对擦除的核心动机做出了解释：它使得泛化的客户端可以用非泛化的类库来使用，反之亦然，这经常被称为“迁移兼容性”。在理想情况下，当所有事物都可以同时被泛化时，我们就可以专注于此。在现实中，即使程序员只编写泛化代码，他们也必须处理在Java SE5之前编写的非泛型类库。那些类库的作者可能从没有想过要泛化它们的代码，或者可能刚刚开始接触泛型。

      因此Java泛型不仅必须支持向后兼容性，即现有的代码和类文件仍旧合法，并且继续保持其之前的含义；而且还要支持迁移兼容性，使得类库按照它们自己的步调变为泛型的，并且当某个类库变为泛型时，不会破坏依赖于它的代码和应用程序。通过允许非泛型代码与泛型代码共存，擦除使得这种向着泛型的迁移成为可能。

      尽管如此，但是我们还是可以通过反射得到一些蛛丝马迹的。通过反射的getGenericParameterTypes去拿到泛型中的参数类型。

package Generic;

import java.lang.*;
import java.util.*;

public class GenericTest {

    public static void main(String[] args) throws Exception {
        
        /**
         * 通过反射去获取方法的泛型参数化类型，通过其他方式是无法知道泛型的参数类型，因为在泛型中
         * 编译后去掉了泛型化。
         */
        Method method = GenericTest.class.getMethod("applyVector", Vector.class,Map.class);
        Object[] ParameterTypes = method.getParameterTypes();
        //System.out.println(ParameterTypes);
        /*for(Object ParameterType : ParameterTypes ){
            System.out.println(ParameterType);
        }*/
        ParameterizedType type = (ParameterizedType) method.getGenericParameterTypes()[0];
        System.out.println("type.getRawType()  = "+type.getRawType());
        System.out.println("type.getActualTypeArguments = "+type.getActualTypeArguments()[0]);
    }
    
    public static void applyVector(Vector<Date> v, Map<String,String> map){
        
    }

}

   得到的结果是：

type.getRawType()  = class java.util.Vector
type.getActualTypeArguments = class java.util.Date

      由于有了这个反射能得到泛型的参数类型后，还是挺兴奋的。但是我们不能经常去使用反射，这毕竟还是一个耗时耗力的事情。所以在泛型的很多代码编写上就有新的尝试了。

• 泛型的定义加上了上边界和下边界
• 加入Class类型的代码

　  1.泛型的定义加上了上边界和下边界　

      因为擦除移除了类型信息，如果使用无界泛型参数调用的方法只是那些可以用Object调用的方法。如果能够将某个参数限制为某个类型子集，我们就能调用这个类型子集去调用方法了。所以在Java泛型中用了extends这个关键字，但是此时extends和在普通情况下面所具有的意义是完全不同的。

     

package Generic;

import java.awt.Color;

interface HasColor{java.awt.Color getColor();}

class Colored<T extends HasColor>{
    T item;
    Colored(T item){ this.item = item;}
    T getItem(){
        return item;
    }
    java.awt.Color color(){return item.getColor();}
}

class Dimension{public int x , y, z;}

//this won't work -- class must be first, then interface;
//calss coloredDimension<T extends HasColor & Dimension>

class ColoredDimension<T extends Dimension & HasColor>{
    T item;
    ColoredDimension(T item){this.item = item;}
    T getItem(){return item;}
    java.awt.Color getColor(){return item.getColor();}
    int getX(){return item.x;}
    int getY(){return item.y;}
    int getZ(){return item.z;}
}

interface Weight{int weight();}

class Solid<T extends Dimension & HasColor & Weight>{
    T item;
    Solid(T item){this.item = item;}
    T getItem(){return item;}
    java.awt.Color color(){return item.getColor();}
    int getX(){return item.x;}
    int getY(){return item.y;}
    int getZ(){return item.z;}
    int weight(){return item.weight();}
}

class Bounded extends Dimension implements HasColor ,Weight {

    @Override
    public int weight() {
        // TODO Auto-generated method stub
        return 0;
    }

    @Override
    public Color getColor() {
        // TODO Auto-generated method stub
        return null;
    }
    
}

public class BasicBounds {
 
    public static void main(String[] args) {
        Solid<Bounded> solid = new Solid<Bounded>(new Bounded());
        System.out.println(solid.weight());
        System.out.println(solid.color());
        System.out.println(solid.getY());
    }

}

     所以你会发现，原来extends在泛型使用中不仅仅可以被用来限定上边界class，还可以用来限定上边界interface。而且，在此之后我们可以使用class或者interface中的类型变量或者是方法，这样子我们就可以很好的利用Java提供的这个机制去构建一些泛型关系。

2.加入Class类型的代码

     既然被擦除了，那就在调用的时候再将这个类型传入就好了。这个也是挺不错的方法之一。

package Generic;

class ClassAsFactory<T>{
    T x;
    public ClassAsFactory(Class<T> kind){
        try {
            x= kind.newInstance();
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

class Employee{}

public class InstantiateGenericType {

    public static void main(String[] args) {
        ClassAsFactory<Employee> fe = new ClassAsFactory<Employee>(Employee.class);
        System.out.print("ClassAsFactory<Employee> succeed");
        ClassAsFactory<Integer>  fi = new ClassAsFactory<Integer>(Integer.class);

    }
}

       发现了没有，在new实例化这个泛型的时候，我们再将这个实例化的类型传入，接着再将这个newInstance就好了。

       下一篇，将介绍泛型用于程序设计中的实例，不错的实例。