在之前的文章中分析过了多态，可以知道多态本身是一种泛化机制，它通过基类或者接口来设计，使程序拥有一定的灵活性，但是这种通过基类或者接口实现的灵活性对程序来说约束性还是太强了。我们总是希望编写出更加通用的代码，而不是限于某个基类或者接口，所以在java5是推出了泛型的概念。

泛型类型

泛型术语的意思是“适用于许多的类型”，它的目的是希望类和方法可以具备最广泛的表达能力。个人认为可以从通用程序和持有对象两个方面来理解泛型，就像在书写的代码时，程序很有可能会要求我们持有一些对象，这些对象并没有固定指哪一个类型，在缺失泛型的情况下，我们有几种设计方法，比如使用多态性、或者直接持有一个Object对象、又或者选择一一针对来设计这个程序，很明显，多态性的限制在基类或者接口上，Object对象虽然也能达到效果却很不安全，而一一对应则会产生极多的重复代码，在java1.5之后，我们可以通过泛型来优雅的设计出满足需求的程序。

就像编写一个容器类我们希望它可以被特化为包含任何特定种类的对象，并且对于每个队列对象，我们都可以定义它要保存对象类型。如下所示：

/**
***泛型示例
**/
class Generic<T>{
    private T type;
    public Generic(T type){
        this.type = type;
    }
    public T getType() {
        return type;
    }
    public void setType(T type) {
        this.type = type;
    }
}

这个类Generic<T>的声明就是泛型声明，表示Generic<T>是一个泛型类，其中T就是那个我们可以定义的保存的类型，被称为类型变量。类型变量可以用单个字母来命名如：E指的元素Element，K指的键key，V指的值value，T指的类型Type。
创建的这个对象的时候则需要告诉编译器我们制定的类型T，如：Generic<String> strCell = new Generic<String>("hello");、Generic<Integer> intCell = new Generic<Integer>();，
可以看到对于两个引用strCell和intCell我们指定了两个不同的类型String和Integer，但是两个引用的类型其实是一样的，如下所示：

public static void main(String[] arrg0){
        Generic<String> strCell = new Generic<String>("hello");
        Generic<Integer> intCell = new Generic<Integer>(0);
        boolean same = strCell.getClass() == intCell.getClass();
        System.out.println("--same = "+same);
        
}
输出：
--same = true

这是因为泛型的类型参数只是声明了要被构造的对象信息，使得编译器可以检查输入的类型是否正确，编译器会使用最泛化的对象（通常是Object）来表示类型参数，然后适用强制装换保证程序的正确性，所以运行期的对象没有类型参数的信息。因为自始至终都只是这一个类Generic被定义，，所以调用静态方法的时候时没有T的类型信息的，即如果存在类型参数T的泛型类，在它的内部不能将T用在静态区域，
如静态字段，静态方法，静态代码块中。这个结论也指出了类型参数的使用范围：可以出现在放置具体类名的非静态的声明中，如字段声明，方法返回类型，参数列表，局部变量，嵌套类型声明，除了创建类型E或者数组T[]。
对于不能创建具体的对象或数组对象，和不能拥有类型为T的静态字段是同一个道理，单一的类只有单一的toArray定义，编译器必须在编译期确定将要创建那些类型对象或数组的代码，但是我们并不知道T具体是什么类型，只靠Generic类是无法完成这个功能的。如果非要在其中创建这个对象或数组，可以考虑用反射机制来实现，这部分后面会有提到。

边界

在Generic<T>中，虽然类型参数T可以指定任何想要的引用类型，但是，有时候我们也需要为参数类型定义某些限制，例如：

class SortedCollection<T extends Comparable<T>>{
    /**
     * method in here
     */
}

在这个类中，T extends Comparable<T>表明我们需要传入的类型参数需要实现Comparable接口，不然类内部的使用了compareTo方法的地方可能出错或者无法达到我们预期的效果。其中Comparable接口为T的上界，T则是一个有界的类型参数。这里解释一下这个extends，这里并不单单表示继承，它扩展为继承，实现的意思。在《Java程序设计语言》中的原话有写道：类型边界可以通过以下方式来表示这样的多重依赖关系：声明类型参数扩展了一个类或接口，并在后面跟随一个由&分隔的其他必须实现的接口的列表。

既然有泛型类，那么就会涉及到内部类的问题，比如一个类中嵌套了一个泛型类型，那么会有什么特别的地方么？这种情况就是嵌套泛型类型了。

嵌套泛型类型

就像在之前梳理的内部类中，嵌套一个泛型类型也有几种情况，如普通内部泛型类、静态内部泛型类、匿名内部泛型类。这里静态内部泛型类也会存在一个问题，代码如下：

class Generic<T>{
    private InnerClass<T> inner; 
    public InnerClass<T> getInner(){
        return inner;
    }
    static class InnerClass<T>{
        private T name;
        public T getName(){
            return name;
        }
        public void setName(T name){
            this.name = name;
        }
    }
}

在上面这部分代码中，泛型类作为一个静态类被嵌套在Generic类中，这里需要注意的是外部的Generic<T>和内部的InnerClass<T>中，两个类型T的意义是不一样的，虽然说都只是用了相同的字母T表示，很简单的道理，因为静态内部类不需要外部类对象的引用就可以直接创建对象，所以这个InnerClass<T>中的类型跟外围类中的类型T并不关联。
这里提一下，如果两个类型不一样，那么尽量不要用一样的类型T来代表。其他的内部泛型类因为依赖于外围类的引用，反倒是没有这个问题，因为在外部已经有声明为泛型类型之后，内部类是可以访问到这个作用字段的。

使用泛型类型

使用泛型类型的时候，我们需要为类型参数指定我们需要的类型，例如上面的Generic<String> generic = new Generic<String>();,我们为类型参数T指定的类型就是String。同理，如果有多个类型参数，那么就需要为每一个类型参数指定一个类型。看起来这是个很容易的问题，就像刚刚指定的String类型一样，符合我们使用要求就好了，但是考虑到继承机制，比如我们指定的类型T是父类如Number，那么另一个指定为它的子类Integer的泛型类型能不能代入父类Number指定的程序中呢？

public static double count(ArrayList<Number> numberList){
        double count = 0;
        for(Number num :numberList){
            count += num.doubleValue(); 
        }
        return count;
}

这这个方法中，我们需要传入一个ArrayList<Number>类型的参数，在代码中试一下ArrayList<Integer>可以看到会报错，提示：The method count(ArrayList<Number>) in the type GenericDemo is not applicable for the arguments (ArrayList<Integer>)。这就说明泛型类型中指定的类型T只是代表了T类型的泛型类型，和它的子类是没有关系的，即ArrayList<Integer>并不是ArrayList<Number>的子类型，这和数组不一样，数组中Integer[]是Number[]的子类型。那么又有问题了，如果我们程序中有需要这样一个Number的子类怎么办？
这里就需要引入一个概念，即通配符“?”，通过通配符就可以很好的完成我们的设计，就像上面的方法，我们只需要修改一下就可以适用于ArrayList<Integer>,代码如下：

public static double count(ArrayList<? extends Number> numberList){
        double count = 0;
        for(Number num :numberList){
            count += num.doubleValue(); 
        }
        return count;
}

在这里，通配符表示我们可以使用任意的类型，只要它是Number或者它的子类，这里的? extends Number 表示以Number为上界的任意类型，包括Number本身。既然有上界，对应的还有一个下界，即? super Integer表示所有Integer的超类或者接口。看到这里，可能会自然的和有界类型变量相比较，需要注意的是通配符只能存在一个上界或下界，但是有界泛型类型是可以有多个上界的，而且类型参数是没有下界的，例如不能声明成这样T super String。在这里一开始就使用了边界，所以可能会下意识的以为通配符必须要有边界，其实不然，
通配符也可以无界，即直接使用?，隐式的代表是上界为Object对象，即ArrayList<? extends Object>。可以看出通配符是泛型中很重要的一点，它可以使泛型有效的使用，但是通配符本身还是存在局限性：因为通配符表示的是未知的数据类型，那么就无法使用在已知的数据类型的时候。例如：

ArrayList<?> list = new ArrayList<String>();
list.add("test");
ArrayList<? extends Number> list1 = new ArrayList<Integer>();
list1.add(1);

在上面的代码中我为list添加了一个test字符串，但是编译器会提示错误：The method add(capture#1-of ?) in the type ArrayList<capture#1-of ?> is not applicable for the arguments (String)。而list1.add(1)这里，可能会有人很疑惑，明明加进去的是属于Number类型的，为什么还是不行？这是因为在使用泛型时，编译器和运行时系统都不知道你想用的类型是什么，我们不能把传入的Number或它的子类泛化成Number。这其实是合理的，因为传进来的是未知类型,我们无法把一个未知类型转成已知的。不同的是如果是下界有指定，那么它是正确的，如下所示：

ArrayList<? super Integer> list1 = new ArrayList<Number>();
list1.add(1);

它会把传入的类型保存为Integer。虽然通配符本身表示的是未知类型，但是一旦使用了之后，编译器会把它当做一个具有某种具体类型的变量来处理，以便编译器检查对他的使用是否正确。这个未知的具体类型被称为通配符的捕获。尽管捕获可以被当做任意类型，但是不能将通配符类型传递给拥有类型变量定义参数列表的方法中。
虽然通常情况下，我们不希望在使用了List<T>的地方出现List<?>，因为这个通配符代表的类型和类型参数代表的类型兼容性未知。但是有一条规则可以允许被捕获的通配符被表示为未知的类型变量T，即捕获转换。捕获转换无法被应用于类型参数被多个方法使用的情况。只有当类型变量被定义在顶层泛型类型才可以使用捕获转换。最后，我们无法再任何需要知道通配符类型的地方使用通配符引用。

说完了泛型类型，接下来可以看看泛型接口。

泛型接口

和普通的接口类似，泛型接口本质上还是属于接口，只是在接口中使用的类型需要在实际使用中进行指定，即当一个类实现了这个泛型接口，那么需要为泛型接口指定具体类型，代码如下：

class Generic implements IGeneric<String>{

    @Override
    public String get(String name) {
        // TODO Auto-generated method stub
        return null;
    }
    
}
interface IGeneric<T>{
    T get(String name);
}

在类Generic实现接口Igeneric<T>的同时，为它指定了一个类型参数String就可以正常的使用这个接口了。

目前为止，我们看到的泛型都是在类层次上的，现在我们可以看看泛型方法。

泛型方法

在一个类的内部可以定义很多方法，通常情况下我们都会为方法的参数列表指定具体的类型，其实也可以使用泛型，将这个方法的通用型达到最大，在《Thinking in Java》中的原话是这样说的：无论何时，只要你能做到，你就应该尽量使用泛型方法，这句话说明了，如果可以考泛型方法解决的问题，那么就不要使用泛型类，而且对于一个静态方法而言，它是无法访问泛型类内部的类型参数的，就可以使用泛型方法来解决泛型的问题。例如：

class Generic{
    public static <T> T get(T t){
        return t;
    }
}

在类Generic中的方法get是一个泛型方法，它根据用户输入的类型不同而返回不同类型的引用，实际使用的时候，通常也不需要像泛型类一样指定输入的类型参数，编译器会自动帮我们找到具体的类型，即类型参数推断。如果把Generic定义成泛型的，那么这个静态方法反而无法获取类型参数的信息。当然咯，并不是泛型类和泛型方法两者是互斥的，它们是可以同时存在的。
在这里，如果在方法中添加的是基本数据类型，编译器会自动打包成它的包装类。

看了这几部分,下面说一下泛型机制：擦除

擦除：

我们说过很多次，无论泛型类型中可以形成多少种参数化类型，每一个泛型类型都只有一个类。就好像Generic<T>，泛型类型在被擦除后就只剩下一个不加任何修饰的类名，如Generic，即原始类型。类型参数的擦除就是它的第一个边界，如E的擦除是它隐式的上界Object。编译器通过擦除为泛型类型生成一个类定义，当使用类型参数的时候，如果它和通过擦除生成的类型不一致，编译器就会插入一个强制类型转换来保证安全性。由于基础数据类型不是对象类型，所以在泛型中无法使用基础数据类型，如果有需要可以使用它的包装类型。
擦除大体会在两个方面影响我们：
1.运行时擦除
任何在运行时需要知道引用具体的类型都是不允许的，这带来的影响主要有一下几点：
不能创建类型参数的实例或者数组。
不能创建元素类型是参数化类型的数组，除非用于该参数化类型的所有引元都是无界通配符。
不能使用instanceof来查看类型参数是否是哪个实体类型，除非该参数化类型的所有引元是无界通配符。
涉及到类型参数的强制转换都会被替换成它的擦除的强制转换。
catch子句不能捕获由类型参数表示的异常
泛型类不允许直接或间接的扩展Throwable类
不能在类字面常量的表示中使用泛型类型，即不能使用Generic<String>.class。
2.重载和覆盖
过去我们队重载的定义是具有相同名字不同签名的方法，而覆盖则是在子类中可以访问到的和超类具有相同名字和相同签名的方法。但是在涉及泛型的时候，这些概念需要修改一下,相同的签名则变成相同数量的类型变量，且相同的类型变量的边界一样。下面考虑一下覆盖，
我们要做的是覆盖等价的签名，而不是要求相同的签名，即 当两个方法的签名相同时，或他们的擦除相同时，才具有等价性。如果在一个类或接口中，有两个方法它的签名具有等价性，并且名字相同则会报错，套用到子类中，则是如果两个签名等价，名字相同的方法就会隐式的覆盖父类的方法。

可以看到，最后一部分并没有例子附上，只扔了一些理论和结论在这里，如果有兴趣，可以自己思考一下每一点为什么是这样的。个人而言，其实也有些不懂的地方，文中有错误的地方请帮忙指正，，万分感谢~