3分钟快速掌握泛型(Generic)

由于本人能力有限，文中若有错误之处，欢迎指正。
转载请注明出处：http://www.jianshu.com/p/75bc58480c11

什么是泛型?

泛型，即类型参数化。

1. 泛型是 JDK5 中引入的一种安全机制。泛型的引入把运行时期易产生的 ClassCastException 转化到编译时期。(下面有示例)
2. Java中的泛型是伪泛型，在JVM层并不真正支持泛型。在编译检查成功后，相应的class文件中已经没有了泛型的信息。这种机制叫做 擦除补偿 机制。(下面有示例)
3. 泛型使用最广泛的地方是Java集合框架。
4. 可以利用泛型的特点，设计出更加灵活的API。

// JDK5之前没有泛型
List strs1 = new ArrayList();
strs1.add("hello world!");
// 可以添加，但在使用是可能是产生java.lang.ClassCastException
// strs1.add(123);
String str1 = (String) strs1.get(0);

// JDK6有泛型
List<String> strs2 = new ArrayList<String>();
strs2.add("hello world!");
// strs2.add(123); // 编译时期直接报错
String str2 = strs2.get(0); // 不用强制类型转换

// 通过反射证明伪泛型
List<String> list = new ArrayList<>();
list.add("hello world!");
Method add = list.getClass().getMethod("add", Object.class);
add.invoke(list, 111);
System.out.println(list.get(1)); // java.lang.ClassCastException

泛型类

public class Container<V> {

    private V value;

    public Container(V v) {
        value = v;
    }

    public V getValue() {
        return value;
    }

    public void setValue(V value) {
        this.value = value;
    }
}

泛型接口

public interface Generator<T> {
    public T next();
}

泛型方法

使用原则： 无论何时，只要你能做到，你就应该尽量使用泛型方法。也就是说，如果使用泛型方法可以取代将整个类泛化，那么应该优先采用泛型方法。

public class Main {

    public static <T> void outPrint(T t) {
        System.out.println(t);
    }

    public static void main(String[] args) {
        outPrint("findingsea");
        outPrint(123);
        outPrint(true);
    }
}

通配符

使用原则(PECS)
1.如果要从集合中读取类型T的数据，并且不能写入，可以使用 ? extends 通配符；(Producer Extends)
2.如果要从集合中写入类型T的数据，并且不需要读取，可以使用 ? super 通配符；(Consumer Super)
3.如果既要存又要取，那么就不要使用任何通配符。

• ?

无边界通配符，它的使用形式是一个单独的问号：List<?>，也就是没有任何限定，不做任何限制。

• 上限(<? extends T>)

List<? extends Fruit> flist = new ArrayList<Apple>();
// 编译错误，不能添加任何类型
// flist.add(new Apple());
// flist.add(new Fruit());
// flist.add(new Object());
flist.add(null); // null不处于任何类型
// 可以获取到具体类型
Fruit f = flist.get(0);

flist 的类型是 List<? extends Fruit>，我们可以把它读作：一个类型的 List， 这个类型可以是继承了 Fruit 的某种类型。注意，这并不是说这个 List 可以持有 Fruit 的任意类型。而是我们不知道这个 List 到底持有什么类型，所以不能安全的添加一个对象。 另一方面，如果调用某个返回 Fruit 的方法，这是安全的。因为我们知道，在这个 List 中，不管它实际的类型到底是什么，但肯定能转型为 Fruit，所以编译器允许返回 Fruit。

• 下限(<? super T>)

List<? super Apple> apples = new ArrayList<>();
apples.add(new Apple());
apples.add(new RedApple());
// apples.add(new Fruit()); // 编译错误

apples 的类型是 List<? super Apple>，它表示某种类型的 List，这个类型是 Apple 的基类型。也就是说，我们不知道实际类型是什么，但是这个类型肯定是 Apple 的父类型。因此，我们可以知道向这个 List 添加一个 Apple 或者其子类型的对象是安全的，这些对象都可以向上转型为 Apple。但是我们不知道加入 Fruit 对象是否安全，因为那样会使得这个 List 添加跟 Apple 无关的类型。

写在最后

1. 开发中，泛型使用最多的地方就是集合框架。大部分情况下泛型的使用还是比较简单的。
2. 另外，泛型的使用多见于一些开源框架中。泛型的引入大大增强了API设计的灵活性。
3. 如果你不确定一个地方能不能使用泛型，那么请尝试使用它。