目录
1、导读
泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。Generic有“类的，属性的”之意，在Java中代表泛型。泛型作为一种安全机制而产生。
2、为何需要泛型？
我们知道集合(Collection、Map之类的容器)是用来存储任意对象(Object)的一系列“容器类或者接口”，注意这里的“任意对象”,就是指我们可以在这些类或接口中存放任意类型的对象，但这些对象在存储之前都需要统一向上转型为Object类型(因为Object类是所以类的的父类)，比如类ArrayList就属于“集合类”，我们可以用这个类来存储任意对象：
package bean;
import java.util.ArrayList;
public class ArrayListDemo {
public static void main(String[] args) {
//首先我们创建一个ArrayList对象
ArrayList al = new ArrayList();
//往"容器"添加元素：我们添加了字符串"哈哈",数字2,boolean类型true，最后我们甚至添加了自己。
al.add("哈哈");
al.add(2);
al.add(true);
al.addAll(al);
//由于ArrayList类覆盖了toString()，这里我们可以直接打印查看效果：
System.out.println(al);
}
}
最后打印出来的字符串是：[哈哈, 2, true, 哈哈, 2, true]
值得注意的是：这里的2不是int而是Integer，因为ArrayList只能存对象，而“添加它自己”addAll(al)的实质是将al中的所有元素再存入al中，正如打印效果显示的一样，我们成功添加了类型不一样的对象：有String，有Integer、还有Boolean。当然，你可以添加任意你想要添加的对象。因为这些对象在存入“容器”al中时会全部转型为Object类型，有没有觉得这样的“容器”用起来会很爽，什么东西都能往里放。但是，便捷往往会付出相应代价。
我们将各种类型的元素存入“容器”中当然不是让它睡上一觉，我们需要将存储的元素取出使用。对于这些“容器”，我们一般使用迭代器Iterator来获取每一个元素。(这里不进行迭代器使用说明，只需理解迭代器是取出"容器"中元素的工具就行).
假设现在我们需要对我们上面创建的“容器”al中的元素进行操作：打印容器中字符串的长度，即“哈哈”的长度。
1 package bean;
2
3 import java.util.ArrayList;
4 import java.util.Iterator;
5
6 public class ArrayListDemo {
7 public static void main(String[] args) {
8 //首先我们创建一个ArrayList对象,并添加对象
9 ArrayList al = new ArrayList();
10 al.add("哈哈");
11 al.add(2);
12 al.add(true);
13
14 //使用迭代器Iterator进行遍历，并打印容器中字符串的长度：
15 //注：next()方法是按照容器的存储顺序，逐一取出第一个到最后一个对象。
16 Iterator i = al.iterator();
17 while(i.hasNext()){
18 String s = (String) i.next();
19 System.out.println(s.length());
20 }
21 }
22
23 }
这是运行结果：
我们来进行代码分析：while循环中，先用i.next()方法取出第一个元素"哈哈"，然后装换为String类型（因为存进去的时候是Object类型，使用的使用要向下转型），所以接下来打印了“哈哈”的长度=2。接着循环：迭代器取出第二个元素：2，但这是Integer类型不能强制装换为String类型，所以抛出异常：ClassCastException：类型转换异常。
这就是“能存万物”所带来的代价：我们在使用“容器”存储对象并调用时就换存在“类型转换异常”的安全隐患，但这需要在运行后才能得知，编译时无法发现。所以我们该如何解决这个问题呢？我们发现问题在于“类型转换异常”，所以我们只要保证“容器”中存储的是同一类型的元素就不会出现这个异常了。类似数组的定义一样：如 int[] 就表示专门用来存储int类型数据的数组，String[] 就是用来存储String类型数据的数组。我们只要将“容器”标上相应类型的标签就可以了。看到这里，你应该已经理解了泛型的由来，这就是泛型的设计：引入类型参数的概念，即对对象类型进行申明。
3、泛型的定义格式
格式为：类名<类型名>，如：
1 package bean;
2
3 import java.util.ArrayList;
4 import java.util.Iterator;
5
6 public class ArrayListDemo {
7 public static void main(String[] args) {
8 //首先我们创建一个ArrayList对象,并申明泛型类型为String类型：只能存储String类型的对象
9 ArrayList<String> al = new ArrayList<String>();
10 al.add("哈哈");
11 al.add("asdafa");
12 al.add("tobeyourself");
13
14 //使用迭代器Iterator进行遍历，并打印容器中字符串的长度：这里迭代器也使用了泛型
15 Iterator<String> i = al.iterator();
16 while(i.hasNext()){
17 String s = (String) i.next();
18 System.out.println(s+"的长度为="+s.length());
19 }
20 }
21
22 }
运行结果为：
3、泛型的好处
除了解决上面的安全隐患即抛出异常问题，泛型的类或接口在取出对象时将不需要再进行向下类型转换，因为存储的时候就是该类型 。
另外，泛型的使用让安全问题在编译时就报错而不是运行后抛出异常，这样便于程序员及时准确地发现问题。
4、什么时候使用泛型？
一般类或接口在api文档中的定义中带有<E>标识的，在使用的时候都需要使用泛型机制。如ArrayList<E>、Iterator<E>。
5、泛型的擦除
泛型是运用在编译时期的技术：编译时编译器会按照<类型名>的类型对容器中的元素进行检查，检查不匹配，就编译失败。如果全部检查成功，则编译通过，但，编译通过后产生的.class文件中并没有<类型名>这个标识，即类文件中没有泛型，这就是泛型的擦除。
一句话总结就是：在.java文件运用泛型技术时，编译器在文件编译通过后自动擦除泛型标识。
由于泛型的擦除，类文件中没有泛型机制，同时也没有使用向下类型转换，那么为何运行时无异常？
6、泛型的补偿
编译器在擦除泛型后，会自动将类型转换为原定义的"泛型"，这样就不必再做向下类型转换了。
泛型的擦除和补偿 这两个机制都是编译器内部自动完成的，了解其原理即可。
7、泛型的应用
7.1【泛型类】
所谓的泛型类就是运用到泛型技术的类，如上面讲到的ArrayList<E>，Iterator<E>等都是java中的泛型类，这些类都是Java已经定义好的泛型类，直接使用就可以了。但有时候我们会遇到这样的问题：
假设我们现在有两个自定义类：Worker类和Student类，现在我们需要一个工具类Tool来获取Worker对象和Student对象，并能对对象进行操作。
分析：
我们可能会想到将Worker和Student类作为Tool类的成员变量，以此来实现对这两个类的操作。但这样有一个问题，就是如果这不是两个类而是很多类，甚至说无数个类，即Tool类可以操作任意类，这种通过添加成员变量来实现调用对象的方法显然不可行。注意这个“添加任意对象”，这不就是上面说的ArrrayList<E>这些类所具有的特点吗？泛型类就是为了解决“添加任意对象”而产生的，这里提到的ArrayList<E>属于已定义泛型类(Java中自带的)，这里我们要用到Tool类来“存储任意对象”，所以要将Tool类定义为泛型类，这就是根据需求自己设计的自定义泛型类：
首先我们先简单的定义一下:Worker类和Student类：
Worker类：
1 package bean;
2
3 public class Worker {
4 private String name;
5 private int age;
6 Worker(){
7
8 }
9 Worker(String name,int age){
10 this.name = name;
11 this.age = age;
12 }
13 public String getName() {
14 return name;
15 }
16 public void setName(String name) {
17 this.name = name;
18 }
19 public int getAge() {
20 return age;
21 }
22 public void setAge(int age) {
23 this.age = age;
24 }
25
26 }
Student类：
1 package bean;
2
3 public class Student {
4 private String name;
5 private String sex;
6 Student(){
7
8 }
9 Student(String name,String sex){
10 this.name = name;
11 this.sex = sex;
12 }
13 public String getName() {
14 return name;
15 }
16 public void setName(String name) {
17 this.name = name;
18 }
19 public String getSex() {
20 return sex;
21 }
22 public void setSex(String sex) {
23 this.sex = sex;
24 }
25
26 }
现在我们需要将Tool类定义为泛型类：(注意格式)
1 package bean;
2
3 public class Tool<E> {
4 private E e;
5
6 public Tool(E e1){
7 this.e = e1;
8 }
9
10 public E getE() {
11 return e;
12 }
13 public void setE(E e) {
14 this.e = e;
15 }
16
17 }
这里我们写的很简单，但已经满足需求了，重点在于泛型类的写法：Tool<E>，这里的E字母可以写你自己喜欢的代码，这也就是类型参数的应用，E相当于一个类型参数，代表了Tool<E>可以传入任意对象，下面我们具体使用来看看效果：
1 package bean;
2
3 class Tooltest{
4 public static void main(String[] args) {
5 //假设有两个对象：一个学生，一个工人
6 Student t1 = new Student("张三","男");
7 Worker w1 = new Worker("李四",20);
8
9 //现在我们使用Tool类来调用t1和w1
10 Tool<Student> ts = new Tool<Student>(t1);
11 Tool<Worker> tw = new Tool<Worker>(w1);
12
13 //打印查看效果
14 System.out.println("使用ts调用t1中的数据："+ts.getE().getName()+":"+ts.getE().getSex());
15 System.out.println("使用tw调用w1中的数据："+tw.getE().getName()+":"+tw.getE().getAge());
16 }
17 }
打印结果为：
使用ts调用t1中的数据：张三:男
使用tw调用w1中的数据：李四:20
7.2【泛型方法】
泛型方法类似于静态类的设计，一般的方法传入的参数是固定类型的，如public void show(int i){}这个方法的参数类型固定为int，但是泛型方法可以传入指定的参数类型。一般泛型定义有两种形式：
1）使用泛型类的参数类型来定义(常用)：
如泛型类Tool<QQ>，它的泛型参数即为QQ。那么泛型方法可以这样写：public void show(QQ qq){}.
2）使用自定义的参数类型来定义：
如果我们需要自定义参数类型，那么我们把泛型参数放在方法上就可以了(放在返回值类型之前)：public <AA> void show(AA aa){}。
注：静态方法不能访问类的泛型，如果需要泛型，我们只能使用方法2），在方法上使用泛型即可：public static <AA> void show(AA aa){}
7.3【泛型接口】
和上面一样的道理，当我们不确定使用对象的类型时，运用泛型就可以解决问题，泛型接口和泛型类的使用是一样一样的。
我们只需要注意，在实现泛型接口时有两种情况：这里假设有泛型接口interf<AA>，它的实现类是Tool。
1)确定实现的泛型接口的参数类型：
假设Tool类需要String类型的参数，那么实现可以直接写：class Tool implements interf<String>{}即可。
2)不确定实现的泛型接口的参数类型：
这时候我们需要泛型类来实现classTool<BB> implements interf<BB>{}.
8、泛型の通配符：？
当我们不确定传入的对象类型时我们就可以使用？来代替。“？”即泛型通配符。
9、泛型的限定
我们知道使用泛型类时：如果明确参数类型，那么泛型就代表一种类型；如果使用通配符？，那么泛型就代表任意类型。但有时候我们希望指定某些类型(不是一个，也不要所有)能作为参数类型，这应该怎么办呢？
Java中利用泛型的限定解决了这个问题，即泛型的限定。我们只需要按这样的格式书写：
上限：<？ extends E>表示参数类型是E及其所有子类。
下限：<? super E>表示参数类型是E及其所有超类(即父类)。
https://www.cnblogs.com/fzz9/articles/7674561.html
作者：风之之