泛型是个啥
Java 泛型是 JDK 5 中引入的一个新特性，其提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。
通过将数据类型参数化，泛型给JAVA代码带来了不少的便利性。因此泛型也成为了许多框架代码中的常客，如日常使用的ArrayList、LinkedList等，其实都是泛型的延伸造化。为了更好的利用好泛型，我们有必要了解一下泛型的便利之处。
泛型用途
代码复用
在引用泛型之前，针对相似逻辑但不同类型对象的转换逻辑，我们可能需要编写多套代码实现。
public Map<String,Sword> transferSword(List<Sword> list){
Map<String,Sword> map = new HashMap<>();
for (Sword v : list) {
String desc = v.getDesc();
map.put(desc, v);
}
return map;
}
public Map<String,Staff> transferStaff(List<Staff> list){
Map<String,Staff> map = new HashMap<>();
for (Staff v : list) {
String desc = v.getDesc();
map.put(desc, v);
}
return map;
}
复制代码通过结合上函数式编程，我们就可以将转换的逻辑抽象出来，不再受限于类型的问题。从而实现代码的最大程度的复用。
public <K,V> Map<K,V> transfer(List<V> list, Function<V,K> function){
Map<K,V> map = new HashMap<>();
for (V v : list) {
K apply = function.apply(v);
map.put(apply, v);
}
return map;
}
public Map<String,Staff> transferStaff(List<Staff> list){
return transfer(list, Staff::getDesc);
}
public Map<String,Sword> transferSword(List<Sword> list){
return transfer(list, Sword::getDesc);
}
复制代码确保类型安全
在没有泛型前，如果我们想要实现参数化数据类型的效果，往往需要把相对应的参数定义为Object基类。以日常我们使用的数组为例子，数据类型参数化后的结果如下所示：
然而，这样的设计其实是存在极大风险的，相当于一个数组内可能存在不同类型的数据。如果在取出的时候执行了强制转换，那么此时就可能出现ClassCastException。
而如果通过泛型定义，编译器就可以在添加元素的时候对加入的类型做判断。从而避免一些取值时候的不安全问题的发生。
消除强制转换
使用Object实现的基类数组还存在一个比较“恶心”的问题，每次取出数据的时候，都需要对取出的对象做强制转换的逻辑，十分不优雅。
List<Object> arrays = new ArrayList<>();
arrays.add("");
String a = (String) arrays.get(0);
复制代码而采用了泛型后，编译器会自动转换泛型对象的数据格式，从而避免出现需要多次强制转换的情况。
List<String> arrays = new ArrayList<>();
arrays.add("");
String a = arrays.get(0);
复制代码泛型的用法
使用泛型的方法主要包括两类：泛型类/接口、泛型方法
泛型类/接口
泛型类的使用方法主要通过类后设置类型参数变量，具体的语法如下所示：
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
......
}
复制代码泛型接口同泛型类的使用方法类似，都是在类/接口名后设置类型参数变量的方式：
public interface List<E> extends Collection<E> {
...
Iterator<E> iterator();
...
}
复制代码常见的Collection的对象如：ArrayList、LinkedList等，都是采用泛型类的编写方式。而泛型接口与泛型类的不同在于，泛型接口一般都是用于定义顶层的类型用的，如List、Collection这些顶层框架的接口就会使用到这样的编写方式。
泛型方法
泛型方法的使用方式也不复杂。通过在方法返回值前设置类型参数变量即可。如下是ArraysList中的一个泛型方法：
public <T> T[] toArray(T[] a) {
if (a.length < size)
// Make a new array of a's runtime type, but my contents:
return (T[]) Arrays.copyOf(elementData, size, a.getClass());
System.arraycopy(elementData, 0, a, 0, size);
if (a.length > size)
a[size] = null;
return a;
}
复制代码通配符及上下限
通配符
泛型在使用的过程中，除了通过定义方法和类，在创建对象的时候还可以通过<?>表达泛型的概念，如下是一个实际的例子：
List<?> arrays;
复制代码其中<?>被称为通配符，上述代码的含义是可以匹配任意类型的数组，同List表达的意思本质上是一致的。
上下限
在实际情况中，通配符还存在一些需要界定范围的情况。比如需要创建一个仅能存放Float、Double、Integer等数字类型的数组，那么最简单的List<?>的方法就不能够满足需求了，需要做更仔细的约束，而这就涉及到上下限了。上下限，顾名思义主要有两个：
- 上限：关键词是extends，其表达的意思是，数组arrays内的类都继承自Number，是Number或者Number的子类。代码如下：
List<? extends Number> arrays = new ArrayList<>();
复制代码- 下限：关键词是super，其表达的意思是，对应的类都是Number或Number的父类。代码如下：
List<? super Number> arrays = new ArrayList<>();
复制代码上下限的概念不复杂，但你可能有疑惑了，这两该咋用呢？别急，让我们来看下面这个例子：
Integer myInteger = 1;
List<? extends Number> arrays1 = new ArrayList<>();
arrays1.add(myInterger); // 这个会报错
for (Number number : arrays1) {//不会报错
......
}
List<? super Number> arrays2 = new ArrayList<>();
arrays1.add(myInterger); // 这个不会报错
for (Number number : arrays1) {// 报错
......
}
复制代码上述代码想表达的意思很简单：
在添加的时候，往泛型上限表达的数组arrays1中添加Integer对象报错了，但是在往下限数组arrays2中添加元素的时候却没有报错。在遍历的时候，对arrays1按Number做遍历没有报错，但是对arrays2按Number遍历元素却报错了。这是为什么呢？我们逐一来分析：
添加数据：
在添加数据时，List<Integer>、List<Long>这些类型都可以理解为List<?>或者List<? extends Number>的子类型。这时候如果往List中add数据，编译器没法判断添加的是Integer、Integer还是Double类型。可能会引发类型不一致的问题，这显然和泛型的设计是相悖的。因此Java为了保证类型一致，不允许往泛型上限的数据内添加元素。
然而，对于List<? super Number>来说，其可以理解为List<Number>的父类型，显然List<Number>是可以添加Numer的子类型数据的。
遍历数据：
而在遍历数据的时候，情况就相反了。List<? extends Number>确保了其子类都是继承自Number的。因此可以采用Number对象进行遍历。
但是对于List<? super Number>的数组来说，情况就相反了。因为编译器没法确定所遍历到的对象究竟是Number还是Number的父类，因此只能采用Object对象进行遍历，而并不支持按照Number对象进行遍历的方式。
适用范围
结合上述的讨论，其实还可以得出一个比较重要的点：通配符下限支持添加、通配符上限支持遍历。 由此在方法的设计上，可以优先考虑以通配符上线作为入参，以通配符的下限作为方法的出参。下面是一个具体的示例：
public static List<? super Number> transfer(List<? extends Number> numbers){
List<? super Number> outputs = new ArrayList<>();
for (Number number : numbers) {
outputs.add(number);
}
return outputs;
}
复制代码泛型原理
介绍了这么多泛型的定义和用法，那么泛型本身又是如何实现的呢？
相比较C++的泛型实现方式（模版 + 重载），其实JAVA的实现方式很简单，编译器会在编译的时候将使用泛型的类型给擦除掉，都当作默认的Object对象进行处理。这种实现方式也被称为类型擦除。且实际上，编译器并没有根据类型编译出新的代码，JAVA所实现的泛型，也被称为假泛型。
泛型翻译
知道了泛型的实现原理以后，我们还需要关注一种情况。这里首先引入泛型类Pair：
public class Pair<T> {
private T first;
public void setFirst(T first) {
this.first = first;
}
}
复制代码紧接着我们继承该泛型类，并实现一个IntPair对象。IntPair对象中，对原有的set方法做了一次重写。
public class IntPair extends Pair<Integer>{
@Override
public void setFirst(Integer first) {
super.setFirst(first);
}
}
复制代码但是借由上面对泛型原理的分析，我们不难理解Pair对象的set的方法其实会被翻译成Obejct对象，即如下所示：
public class Pair<Object> {
private Object first;
public void setFirst(Object first) {
this.first = first;
}
}
复制代码但是我们子类的方法确实实打实的Integer对象呀，这还如何实现重写呢？为了探究这块的实现奥秘，我们有必要对IntPair对象做一次反编译：
public class com.example.demo.service.genericparadigm.IntPair extends com.example.demo.service.genericparadigm.Pair<java.lang.Integer> {
public com.example.demo.service.genericparadigm.IntPair();
Code:
0: aload_0
1: invokespecial #1 // Method com/example/demo/service/genericparadigm/Pair."<init>":()V
4: return
public void setFirst(java.lang.Integer);
Code:
0: aload_0
1: aload_1
2: invokespecial #2 // Method com/example/demo/service/genericparadigm/Pair.setFirst:(Ljava/lang/Object;)V
5: return
public void setFirst(java.lang.Object);
Code:
0: aload_0
1: aload_1
2: checkcast #3 // class java/lang/Integer
5: invokevirtual #4 // Method setFirst:(Ljava/lang/Integer;)V
8: return
}
复制代码可以看到，编译器实际上生成了两个方法，一个是预期重写的setFirst(Integer i)方法，而另外一个则是父类的setFirst(Object i)方法。通过上述编译的代码不难看出，java实际上是在setFirst(Integer i)中调用了setFirst(object i)方式实现了代码的重写。这种方式，也被称为桥接方式。通过采用桥接方式，子类就可以成功的对父类中的泛型方法做重载了。
总结
文章从泛型的定义、用法和实现原理各方面介绍了泛型。通过更好的了解泛型，我们才能更合适的用好泛型，提高我们代码的优雅性和效率。
342
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
