1.为什么需要泛型
java中的泛型是java1.5版本中出现的新特性，为java中的一个语法糖。个人理解该泛型的出现，主要是因为没有泛型时，取出元素后需要进行转型的，这是不安全的操作。有可能程序员进行了错误的转型，这样会导致程序出问题。最关键的是，这种问题在编译期，我们是无法发现的，只能在运行时发现。这其实是我们最不能忍受的一点。
为了解决这个问题，让问题提前到编译期就能发现，Java推出的了泛型。泛型最常使用的在各种容器中，例如在容器中需要制定可以接受的参数类型。
2.泛型基本使用
泛型在java中很多使用场景，其中包括泛型类和泛型方法。具体的使用可以看下面的实例。
<code>
//泛型类
class Pair {
K k;
V v;
Pair(K k, V v) {
this.k = k;
this.v = v;
}
public K getK() {
return k;
}
public void setK(K k) {
this.k = k;
}
public V getV() {
return v;
}
public void setV(V v) {
this.v = v;
}
}
</code>
<code>
class Util {
//普通类中的，泛型方法，需要提前声明对应的泛型类型
public static boolean equel(Pair p1, Pair p2) {
return p1.getK().equals(p2.getK()) && p1.getV().equals(p2.getV());
}
}
</code>
<code>
public class GenericTest {
public static void main(String args[]) {
//在<>中指定具体的类型
Pair pair1 = new Pair(1, "hello");
Pair pair2 = new Pair(1, "hello");
Pair pair3 = new Pair(2, "world");
Pair pair4 = new Pair(1, 2);
System.out.println(Util.equel(pair1, pair2));
System.out.println(Util.equel(pair1, pair3));
}
}
</code>
3.泛型的实现
介绍完泛型的基本使用后，我们来看一下Java语言是如何实现泛型的。
Java语言实际实现泛型的方法，个人理解还是比较粗暴的，由编译器帮你实现的强制转型。你所声明的List或List等，在编译完成后的字节码中，实际上的存储为List。尖括号中的类型信息在编译后的类中，不在存在。所以在JVM看来List和List其实就是一个东西。
具体我可以看看，我们写的类和class文件反编译后的类。
<code>
//Java原文件
public class SugarTest {
public static void main(String args[]) {
List list = Arrays.asList(1,23,4,5);
for (Integer i : list) {
System.out.println(i);
}
}
}
</code>
<code>
//Java class文件反编译后的类
public class SugarTest {
public SugarTest() {
}
public static void main(String[] args) {
//Listf反编译后的文件，表现为了一个raw type的List
List list = Arrays.asList(new Integer[]{Integer.valueOf(1), Integer.valueOf(23), Integer.valueOf(4), Integer.valueOf(5)});
//for循环遍历列表，在这里被解释为了迭代器
Iterator var2 = list.iterator();
while(var2.hasNext()) {
//在读取元素时，这里的Java编译器做了一个强制转型
Integer i = (Integer)var2.next();
System.out.println(i);
}
}
}
</code>
4.泛型使用注意点
在基本的Java类型中是有一定的继承关系的，如所有的类都是Object类的子类。但是泛型中参数类型是不可变的，List和List不存在继承关系。如下所示的代码是无法编译通过的。
<code>
//调用函数
List list1 = Arrays.asList(1,24,4);
printList(list1);
//函数打印
private void printList(List list) {
for (Object i : list) {
System.out.println(i);
}
}
Error:(20, 19) java: 不兼容的类型: java.util.List无法转换为java.util.List
</code>
为了解决这类问题，Java语言给出了用通配符 ？和关键字 extends、super搭配使用来做到泛型中的类型继承功能。
这里单独说下通配符 ? 。通配符 ? 表示的未知的与泛型中的T不太一样，例如class表示某种具体的T数据类型的class类，而class则表示某种数据类型未知的class类。List这种类型我们可以进行读操作，但是写操作，只能写入null值到这里List中。
<code>
List list = Arrays.asList(1,23,4,5);
System.out.println(list.get(0));
list.add(4); //error
<code>
具体的使用，一般为 List 或者 List。前者表示为type的子类的集合，而后者表示为type的超类的集合。一般两者的使用上，我们是基于PECS原则，即(producer-extends，consumer-super)。例如，List这种数据类型，对应的add操作（生成者），就应该有extends，而get操作（消费者）则是super。具体例子如下：
<code>
class MyList {
private T t;
public void addAll(List list) {
...
}
public void popAll(List list) {
...
}
}
</code>
<code>
public class ListTest {
public static void main(String args[]) {
List listAdd = new ArrayList<>();
List listPop = new ArrayList<>();
MyList myList = new MyList();
myList.addAll(listAdd);
myList.popAll(listPop);
}
}
</code>
