写在开头
今天的每日一道Java面试题聊的是Java中的泛型，泛型在面试的时候偶尔会被提及，频率不是特别高，但在日后的开发工作中，却是是个高频词汇，因此，我们有必要去认真的学习它。
泛型的定义
什么是泛型？
什么是泛型？这是个好问题，JDK5更新时带来了一个新特性-泛型，所谓“泛型”就是类型参数化，把类型定义成参数的形式（编译期-类型形参），调用时再传入具体的类型（调用时-类型实参）。
了解了定义之后，我们再来直观的感受一下泛型的魅力吧
不使用泛型
List list = new ArrayList();
list.add(1);
int o1 = (int)list.get(0);
使用泛型
List<String> list1 = new ArrayList<>();
list1.add("1");
String s = list1.get(0);
以上就是使用泛型和不适用泛型时代码的对比，可以看出在使用泛型后无需类型强转，这样更安全，代码可读性也更好啦。
泛型中的通配符
在学习和使用泛型的过程中，想必大家已经发现了泛型的尖括号中间的大写字母的差异吧，如< E >、< T >、< N >、<?>、<K,V>，这些都称为泛型的通配符
E - Element (在集合中使用，因为集合中存放的是元素)
T - Type（Java 类）
K - Key（键）
V - Value（值）
N - Number（数值类型）
？ - 表示不确定的java类型
泛型的使用
学以致用，用学相长，乃是大道！
Java中的泛型通常可使用在类、接口、和方法上，我们一个个的看哈
泛型类
泛型类的命名格式：类名<>；尖括号中可以为T、E、K、V等常用通配符，在实例化泛型类时，必须指定具体类型。
//JDK8中ArrayList的源码
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
///
}
上面这段源码java.util.ArrayList中的ArrayList，我们可以看到这就是一个典型的泛型类，我们可以在使用的时候指定不同的类型，基本类型或包装类，或引用类型去存储不同类型的数据，那么现在我们自己去设计一个ArrayList看一下。
【代码示例】
class Arraylist<E> {
private Object[] elementData;
private int size = 0;
public Arraylist(int initialCapacity) {
this.elementData = new Object[initialCapacity];
}
public boolean add(E e) {
elementData[size++] = e;
return true;
}
E elementData(int index) {
return (E) elementData[index];
}
}
【输出】
//测试类调用刚刚手写的ArrayList
public class Test {
public static void main(String[] args) {
Arraylist<Integer> list = new Arraylist<Integer>(10);
list.add(666);
System.out.println(list.elementData(0));
new ArrayList<>();
}
}
//输出：666
【注意】
在实例化泛型类的时候，建议指定具体的泛型类型，否则返回所有类的父类Object。
泛型接口
泛型接口的定义与泛型类类似，直接上代码！
【代码示例】
public interface Box<T> {
public T method();
}
针对泛型接口的实现，我们既可以在实现的时候指定类型，也可以不指定。
【代码示例】
/**
* 实现泛型接口时指定类型为String
*/
public class BoxImpl implements Box<String>{
public static void main(String[] args) {
BoxImpl test = new BoxImpl();
System.out.println(test.method());
}
@Override
public String method() {
return "helloworld";
}
}
当然，我们在开发的过程中，也会遇到一个泛型类在实现泛型接口的时候不指定类型，在实例化的时候，在指定也是OK的。
【代码示例】
class Arraylist<E> implements Box<E>{
///
@Override
public E method() {
return null;
}
}
泛型方法
泛型方法的定义与使用还是直接上代码去分析哈，清晰明了，哈哈哈！
【代码示例】
class Arraylist<E> {
///...
//在上述手写的ArrayList中增加一个toArray的泛型方法
public <T> T[] toArray(T[] a) {
return (T[]) Arrays.copyOf(elementData, size, a.getClass());
}
}
【调用】
public class Test {
public static void main(String[] args) {
Arraylist<Integer> list = new Arraylist<Integer>(3);
list.add(1);
list.add(2);
list.add(3);
Integer[] i = new Integer[3];
//调用泛型方法，将数据转为对应类型数组
i = list.toArray(i);
for (Integer integer : i) {
System.out.println(integer);
}
}
}
在定义泛型方法时，我们可以参考如下图（注意：方法返回类型和方法参数类型至少需要一个！）
静态泛型方法
除了普通的泛型方法外，还有一类静态泛型方法
【代码示例】
//静态泛型方法
public static < E > void printArray( E[] inputArray )
{
for ( E element : inputArray ){
System.out.printf("%s",element);
}
}
在使用静态泛型方法时需要注意：
静态方法的加载先于类的实例化，也就是说类中的泛型还没有传递真正的类型参数，静态的方法的加载就已经完成了，所以静态泛型方法是没有办法使用类上声明的泛型的。只能使用自己声明的< E >
泛型限定符-extends
在泛型的使用中可以使用关键字 extends 限定子类，看下面一段代码：
【代码示例】
class Grandfather {
public String toString() {
return "我是爷爷";
}
}
class Father extends Grandfather{
public String toString() {
return "我是爹";
}
}
class Son extends Father{
public String toString() {
return "我是儿子";
}
}
先定义三个存在继承关系的爷爷-父亲-儿子的类，然后我们重写ArrayList的泛型
class Arraylist<E extends Father>
【调用】
ArrayList<Father> list = new ArrayList<>();
list.add(new Father());
list.add(new Son());
list.add(new Grandfather());
当我们添加Grandfather对象时，编译器报错如上，说明在使用extends进行限定的时候，仅能传入类与子类，同理可推出可以使用关键字 super 限定父类！
泛型擦除
在泛型的使用过程中，有个现象需要特别注意一下，那就是泛型擦除，泛型仅存在于编译时，JVM中是不存在泛型的，我们可以将上述ArrayList.class文件进行反编译，可以通过jad反编译工具，也可以通过网上的在线工具均可哈。
反编译后源码：
//反编译后的代码
package com.javabuild.server.pojo;
import java.util.Arrays;
class Arraylist {
private Object[] elementData;
private int size = 0;
public Arraylist(int initialCapacity) {
this.elementData = new Object[initialCapacity];
}
public boolean add(Object e) {
++this.size;
this.elementData[this.size] = e;
return true;
}
Object elementData(int index) {
return this.elementData[index];
}
public Object[] toArray(Object[] a) {
return (Object[])Arrays.copyOf(this.elementData, this.size, a.getClass());
}
public static void printArray(Object[] inputArray) {
Object[] var1 = inputArray;
int var2 = inputArray.length;
for(int var3 = 0; var3 < var2; ++var3) {
Object element = var1[var3];
System.out.printf("%s", new Object[]{element});
}
}
}
可以发现Java中的泛型均被Object替换，因为在JVM解析的过程中会进行泛型的擦除操作。
