java基础之 泛型

参考文章：

http://blog.csdn.net/s10461/article/details/53941091

定义：
泛型（Generic type 或者generics）是对 Java 语言的类型系统的一种扩展，以支持创建可以按类型进行参数化的类。可以把类型参数看作是使用参数化类型时指定的类型的一个占位符，就像方法的形式参数是运行时传递的值的占位符一样。

解决的问题：
例如，Map类允许您向一个Map添加任意类的对象，即使最常见的情况是在给定映射（map）中保存某个特定类型（比如String）的对象。
因为Map.get()被定义为返回Object，所以一般必须将Map.get()的结果强制类型转换为期望的类型，如下面的代码所示：

Map m = new HashMap();
m.put("key", "blarg");
String s = (String) m.get("key"); 

要让程序通过编译，必须将get()的结果强制类型转换为String，并且希望结果真的是一个String。但是有可能某人已经在该映射中保存了不是String的东西，这样的话，上面的代码将会抛出ClassCastException

理想情况下，您可能会得出这样一个观点，即m是一个Map，它将String键映射到String值。这可以让您消除代码中的强制类型转换，同时获得一个附加的类型检查层，该检查层可以防止有人将错误类型的键或值保存在集合中。这就是泛型所做的工作。 即Map<string,string> m=new HashMap<string,string>();
优点：

• 类型安全

泛型的主要目标是提高 Java 程序的类型安全。通过知道使用泛型定义的变量的类型限制，编译器可以在一个高得多的程度上验证类型假设。没有泛型，这些假设就只存在于程序员的头脑中（或者如果幸运的话，还存在于代码注释中）。
Java 程序中的一种流行技术是定义这样的集合，即它的元素或键是公共类型的，比如“String列表”或者“String到String的映射”。通过在变量声明中捕获这一附加的类型信息，泛型允许编译器实施这些附加的类型约束。类型错误现在就可以在编译时被捕获了，而不是在运行时当作ClassCastException展示出来。将类型检查从运行时挪到编译时有助于您更容易找到错误，并可提高程序的可靠性。

• 消除强制类型转换

泛型的一个附带好处是，消除源代码中的许多强制类型转换。这使得代码更加可读，并且减少了出错机会。
尽管减少强制类型转换可以降低使用泛型类的代码的罗嗦程度，但是声明泛型变量会带来相应的罗嗦。

该代码不使用泛型：

List li = new ArrayList();
li.put(new Integer(3));
Integer i = (Integer) li.get(0); 

该代码使用泛型：

List<Integer> li = new ArrayList<Integer>();
li.put(new Integer(3));
Integer i = li.get(0);

泛型的使用：
命名类型参数
推荐的命名约定是使用大写的单个字母名称作为类型参数。对于常见的泛型模式，推荐的名称是：

•  K —— 键，比如映射的键
•  V —— 值，比如 List 和 Set 的内容，或者 Map 中的值
•  E —— 元素，主要由Java集合(Collections)框架使用
•  T —— 类型，主要用于表示第一类通用型参数
  

泛型类：

泛型类型用于类的定义中，被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。最典型的就是各种容器类，如：List、Set、Map。

定义一个泛型类

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;
    }
}

//泛型的类型参数只能是类类型（包括自定义类），不能是简单类型
//传入的实参类型需与泛型的类型参数类型相同，即为Integer.
Generic<Integer> genericInteger = new Generic<Integer>(123456);

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

//也可以不传入实参，可以是任何类型
Generic generic2 = new Generic(55.55);
Generic generic3 = new Generic(false);

泛型接口：

定义一个泛型接口

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)];
    }
}

泛型方法：

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

     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;
    }

参考（1）

   /**
         * 这个方法显然是有问题的，在编译器会给我们提示这样的错误信息"cannot reslove symbol E"
         * 因为在类的声明中并未声明泛型E，所以在使用E做形参和返回值类型时，编译器会无法识别。
        public E setKey(E key){
             this.key = keu
        }
        */
    }

参考（2）

 //这只是类中一个普通的成员方法，只不过他的返回值是在声明泛型类已经声明过的泛型。
        //所以在这个方法中才可以继续使用 T 这个泛型。
        public T getKey(){
            return key;
        }

参考（3）

 /**
     * 这个方法是有问题的，编译器会为我们提示错误信息："UnKnown class 'E' "
     * 虽然我们声明了<T>,也表明了这是一个可以处理泛型的类型的泛型方法。
     * 但是只声明了泛型类型T，并未声明泛型类型E，因此编译器并不知道该如何处理E这个类型。
    public <T> T showKeyName(Generic<E> container){
        ...
    }  
    */

泛型方法&可变参数

public <T> void printMsg( T... args){
    for(T t : args){
        Log.d("t is " + t);
    }
}

泛型方法&静态方法

静态方法无法访问类上定义的泛型；如果静态方法操作的引用数据类型不确定的时候，必须要将泛型定义在方法上。

public class StaticGenerator<T> {
    public static <T> void show(T t){
    }
}

受限泛型：

•  ？ 是通配符 指代 任意类型
• 泛型的限定上限： <？ extends E> 接受 E 或者 E 的子类型

public class Generic<T extends Number>{
    private T key;

    public Generic(T key) {
        this.key = key;
    }

    public T getKey(){
        return key;
    }
}

//这一行代码也会报错，因为String不是Number的子类
Generic<String> generic1 = new Generic<String>("11111");

• 泛型的限定下限： <?  super   E>  接收  E 或者 E 的父类。

public static void test(List<? super String> list){  
           for (Object object : list) {  
               System.out.println(object);  
           }  
        }  

//这一行会报错，因为Integer不是String的父类
test(new ArrayList<Integer>());

泛型&数组

”不能创建一个确切的泛型类型的数组”

 而使用通配符创建泛型数组是可以的，如下面这个例子：

 

这样也是可以的：

为什么？请参考 http://blog.csdn.net/s10461/article/details/53941091
泛型不是协变的
关于泛型的混淆，一个常见的来源就是假设它们像数组一样是协变的。其实它们不是协变的。List<Object>不是List<String>的父类型。

Integer[] intArray = new Integer[10];
Number[] numberArray = intArray; 

上面的代码是有效的，因为一个Integer是一个Number，因而一个Integer数组是一个Number数组。

但是对于泛型来说则不然。下面的代码是无效的，违反泛型消除。

List<Integer> intList = new ArrayList<Integer>();
List<Number> numberList = intList; // invalid
numberList.add(new Float(3.1415));