每日一道Java面试题：说一说Java中的泛型？

写在开头

今天的每日一道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);

以上就是使用泛型和不适用泛型时代码的对比，可以看出在使用泛型后无需类型强转，这样更安全，代码可读性也更好啦。

泛型中的通配符

在学习和使用泛型的过程中，想必大家已经发现了泛型的尖括号中间的大写字母的差异吧，如、、、<?>、<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解析的过程中会进行泛型的擦除操作。