普通的类和方法只能使用特定的类型：基本数据类型或类类型。如果编写的代码需要应用于多种类型，这种严苛的限制对代码的束缚就会很大。

什么是泛型？让我们依旧从例子开始。

相信大家都知道Python等语言在语法层次就实现了键值对（也就是二元组），用起来很方便，但在Java里面没有，于是你想自己写一个：

class Pair{
  private Object key, value;
    public Pair(Object key, Object value){
    this.key=key;
    this.value=value;
  }
  
  public Object key(){
    return key;
  }
  
  public Object value(){
    return value;
  }
}

是的，这确实很简单，但是还不完美，因为键和值都是Object类型，所以任意的类型的元素都可以放进去，而当把元素取出来的时候则需要强制类型转换，而如果当你取出来元素的时候忘记元素本来的类型时就会在运行程序的过程中报错，比如下面的代码：

Pair a=new Pair("a",123);
// ...很长一段代码
String key=(String)a.value();
// throw ClassCastException: Integer cannot be cast to String

大型工程的代码很多，而写程序的是人，很容易就会忘记放进去的Key和Value原本是什么类型，而且更关键的是，这种错误在写代码的时候根本无法察觉，而要在运行的时候才会发现，这无疑对工程化非常不利（这也是为什么Python很不利于工程化，因为它变量的类型只有在运行过程才能确定）。

那该怎么办？回顾回顾在C++的时候遇到这个问题你会怎么办？

using namespace std;
template <class T1,class T2>
class Pair
{
    public:
    T1 key;  //关键字
    T2 value;  //值
    Pair(T1 k,T2 v):key(k),value(v) { };
};

回想起来了吧，在C++里面解决这个办法就是使用模版，而在Java里也有类似的概念，那就是泛型，但泛型和模版在实现原理上区别很大，在使用上也会有一些区别，在最后面我会着重介绍这一点。

---

一、泛型类

Java里的泛型和C++里很类似，实现上面同样功能的代码如下：

class Pair<K, V>{
  private K key;
  private V value;
    public Pair(K key, V value){
    this.key=key;
    this.value=value;
  }
  
  public K key(){
    return key;
  }
  
  public V value(){
    return value;
  }
}

两个尖括号里面就是表示类里面要用到的泛型的名字的列表，一般约定俗称是用全大写字母（例如KEY, K, K1, VALUE等等），当然你用小写字母（例如class Pair<key, value>）也不会报错，只是可能写着写着你就不记得这是泛型名还是变量名了。

使用起来也很简单

Pair<Integer, String> pairA=new Pair<Integer,String>(1,"abc");
Pair<String, Integer> pairB=new Pair<>("abc",1);
//右边尖括号里的类型说明可以省略不写，因为编译器可以自动根据左边尖括号里的类型推断出来
int key=pairA.key();
String value=pairA.value();
//调用泛型类的方法时不需要强制转换类型
//String key2=pairA.key(); 
//当你弄错了类型的时候编译器会报错并拒绝编译，而不是在运行到一半的时候才出错闪退

还有一个要特别注意的是就是Java中的泛型并不支持基本类型，也就是int, float, double这些，而要用对应的包装类（例如Integer, Float, Double）代替，所以我上面用的是Pair<Integer, String>，而不是Pair<int, String>

---

二、泛型方法

和类可以有泛型参数一样，方法也可以有泛型参数，这和C++的函数模版也比较类似。

继续拿上面那个例子举例，你想给Pair类添加一个静态方法，通过给定Key和Value的值，直接返回一个Pair对象，而不想使用构造函数，这时候就需要用到泛型方法了。

于是你就需要给Pair类添加一个这样的方法

public static <K1, V1> Pair<K1, V1> getPair(K1 key,V1 value) {
  //return new Pair<K1,V1>(key,value);
  //这里的尖括号里同样可以不写类型，直接让编译器推断
    return new Pair<>(key, value);
}

那个尖括号<K1,V1>摆放的位置有讲究，得放在方法修饰符的后面、返回值的前面，不然都会报错

例如public <K1,V1> static Pair<K1, V1>就不可以，public static Pair<K1, V1> <K1, V1>自然也不行。同时，如果类本身有泛型参数的话，方法的泛型参数的名称最好不要和类的泛型参数的相同，所以我在这里用了K1和V1。

需要区别一点的是，方法参数中有泛型类的并不是泛型方法，例如之前代码中的key()和value()就不是泛型方法。

用了这个静态方法后就不再需要构造函数了，可以直接这样生成一个Pair对象：

Pair<String,Integer> pairC=Pair.getPair("abc",123);
//调用泛型方法的时候不再需要像类一样用尖括号语法声明类型
//因为编译器可以自动根据调用函数的参数推断出泛型类型

---

三、类型擦除

Java的泛型非常好用，但是你用着用着可能会发现有些不对劲，你可以试着运行一下下面的代码：

public class ErasedTypeEquivalence {

    public static void main(String[] args) {
        Class c1 = new Pair<String,Integer>().getClass();
        Class c2 = new Pair<Integer,String>().getClass();
        System.out.println(c1 == c2);
    }

}

上面程序的运行结果是true。

这很奇怪，c1和c2应该是不同的类型，但上面的程序却认为它是同一个类型，这是为什么？

因为Java 泛型是使用擦除实现的。这意味着当你在使用泛型时，任何具体的类型信息都被擦除了，你唯一知道的就是你在使用一个对象。因此，Pair<String,Integer> 和 Pair<Integer,String> 在运行时实际上是相同的类型。它们都被擦除成原生类型 Pair。

用更容易理解的语言的话，就是在运行的时候Pair类会变成这样（你可以试着将前面的Pair类编译成class文件再反编译回去）：

class Pair{
  private Object key;
  private Object value;
    public Pair(Object key, Object value){
    this.key=key;
    this.value=value;
  }
  
  public Object key(){
    return key;
  }
  
  public Object value(){
    return value;
  }
}

这里面根本就没有什么类型信息，所有泛型类都变成了Object。

然后下面的代码：

Pair<Integer, String> pairA = new Pair<Integer,String>(1,"abc");
Pair<String, Integer> pairB = new Pair<>("abc",1);
int key=pairA.key();
String value=pairA.value();

在编译之后就变成了这样：

Pair pairA = new Pair(1,"abc");
Pair pairB = new Pair("abc",1);
int key=(Integer)pairA.key();
String value=(String)pairA.value();

等于是编译器在帮你进行了强制类型转换。所以说在广义上来说 Java 的泛型其实就是一种“语法糖”罢了。

而之所以我们不能调用new Pair<Integer,String>("abc","abc")，只是因为编译器在程序编译之前帮我们进行预判断了而已。

正因为泛型类在运行的时候失去了类型信息，所以有很多操作都不能进行，需要多加注意。下面的代码展示了一些例子：

public class Erased<T> {
    private final int SIZE = 100;

    public void f(Object arg) {
        // error: illegal generic type for instanceof
        if (arg instanceof T) {
        }
        // error: unexpected type
        T var = new T();
        // error: generic array creation
        T[] array = new T[SIZE];
        // warning: [unchecked] unchecked cast
        T[] array = (T[]) new Object[SIZE];
    }
}

当然还是有其他办法可以获得泛型类的具体类型的，就是在泛型类的构造函数或泛型方法里加一个Class对象，这里就交给你们自学啦～