背景
在Java推出泛型以前，程序员是可以构建一个元素为Object的集合，该集合是能够存储任意的数据类型对象的，而在使用该集合的过程当中的时候，是需要程序员明确的指定存储每个元素的数据类型，否则是很容易出现ClassCastException异常的。
而Java中的泛型（generics）是jdk5中引入的一个新特性，泛型提供了编译时类型安全监测的机制，该机制允许我们在编译时就监测到非法的类型数据结构。
泛型的本质就是参数化类型，也就是所操作的数据类型被指定为一个参数。
泛型的优点：它使得类型成为安全的，消除了强制类型的转换
泛型类
class 类名称 <泛型标识> {
private 泛型标识 变量名；
}
理论上泛型标识是可以用任何字母标识的，但当然java当中也肯定有自己的规范，所以常用的泛型标识符：T、E、K、V
调用泛型类的语法格式：
类名<具体的数据类型> 对象名 = new 类名<具体的数据类型>( );
在java1.7以后，后面的< >中的具体数据类型就可以省略不写的
类名<具体的数据类型> 对象名 = new 类名< > ( );
泛型派生子类
子类也是泛型类，子类就要和父类的泛型类型要一致
class ChildGeneric<T> extends Generic<T>
当子类不是泛型类的时候，父类就要明确泛型的数据类型
class ChildGeneric extends Generic<String>
泛型类的接口
interface 接口名称 <泛型标识> {
泛型标识 方法名();
}
在使用泛型接口的时候也要注意到
- 要是实现类不是泛型类，接口要明确数据的类型。
- 实现类也是泛型类，实现类要和接口的泛型类型是要一致的。
泛型方法：
修饰符 <T,E,…> 返回值类型 方法名（参数列表）{
方法体…
}
public与返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。
只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
与泛型类的定义一样，此处T是可以任意标识的。
在泛型类当中，我们就可以再单独的定义自己的泛型方法，或者在不是泛型类当中定义泛型方法。
在泛型类当中，泛型方法的泛型是独立于泛型类之外的。
● 成员方法的类型就必须和类的方法是一致的。
● 如果static方法要使用泛型能力，就必须使其成为泛型方法。
● 泛型也是支持可变参数的。
注意事项：
- 泛型类，如果没有指定具体的数据类型，那么这个时候，默认的操作数据类型就是Object类。
- 泛型的类型参数只能是类类型，不能是基本的数据类型
- 泛型类型在逻辑上可以看成是多个不同的类型，但实际上都是相同的类型。
- 在泛型里面不能传入基本数据类型，上面也说了，它的默认类型是Object类，所以传入的数据类型也都继承的是Object类。基本数据类型是没有继承Object类型的，所以不能使用。
类型统配符
类型通配符一般都是使用“？”代替具体的类型实参。
所以类型通配符是类型实参，而不是类型形参。
可以接受定义的类型。
泛型通配符上限
类/接口<? extends 实参类型>
要求该泛型的类型，只能是实参类型，或实参类型的子类类型。
使用泛型通配符这种方式在方法体内是不能添加元素的。
泛型通配符下限
类/接口<？super 实参类型>
要求该泛型的类型，只能是实参类型，或实参类型的父类类型。
泛型通配符的下限虽然在方法内可以添加元素，但是它不保证元素数据类型的要求。
泛型擦除
泛型是Java 1.5版本之后才引进的概念，在这之前是玩去没有泛型的，但是，在泛型引入后，它能很好的与之前的代码进行兼容，那是因为，泛型的信息是只存在与代码编译阶段，在进入JVM之前，将与泛型相关的信息会被全部擦除掉，我们就将这个称为类型擦除。
执行下面的代码：
import java.util.ArrayList;
public class Demo04 {
public static void main(String[] args) {
ArrayList<Integer> integers = new ArrayList<>();
ArrayList<String> strings = new ArrayList<>();
System.out.println("integers的类型为：" + integers.getClass().getSimpleName());
System.out.println("strings的类型为：" + strings.getClass().getSimpleName());
System.out.println(integers.getClass() == strings.getClass());
}
}
我们得到的结果就是它们的本质还都是一个类型，并且它们的getClass也都是相等的。
尽管创建的时候，给的类型是不一样的，但是到底层最实质上的来讲，又都一样，这就是泛型擦除。
无限制类型擦除：
在编译的时候，都是将泛型转换为Object类型进行编译的。
import java.lang.reflect.Field;
public class Demo07 {
public static void main(String[] args) {
Demo06<Integer> demo = new Demo06<>();
//利用反射获取demo对象里面的字节码文件的Class类对象。
Class<? extends Demo06> aClass = demo.getClass();
//获取所有的成员变量
Field[] declaredField = aClass.getDeclaredFields();
//打印成员变量中的所有名称和类型
for (Field field : declaredField) {
System.out.println(field.getName() + ":" + field.getType());
System.out.println(field.getName() + ":" + field.getType().getSimpleName());
}
}
}
public class Demo06<T> {
private T key;
public T getKey() {
return key;
}
public void setKey(T key) {
this.key = key;
}
}
有限制的类型擦除：
当出现上限的时候，我们就在编译的时候，就将数据类型转换为它的上限类型。
在这里泛型方法也是同样的道理：
桥接方法
主要用于实现接口方面。
保持接口和类的实现关系。
在这里要注意到 在编译后的文件里面是有两个Info方法的。
泛型数组
泛型数组在创建的时候是声明带泛型的数组引用，但是不能直接创建带泛型的数组对象。
所以我在创建的时候，可以这样操作。
ArrayList[] arr = new ArrayList[5];
ArrayList<String>[] strArr = arr;
接着来看，我们对这样创建的集合数组添加并读取元素的代码：
在编译器是没有报错的
import java.util.ArrayList;
public class Demo09 {
public static void main(String[] args) {
ArrayList[] arr = new ArrayList[5];
ArrayList<String>[] strArr = arr;
ArrayList<Integer> intArr = new ArrayList<>();
intArr.add(123);
arr[0] = intArr;
String s = strArr[0].get(0);
System.out.println(s);
}
}
执行这个代码，显然报错，报错指出，类型转换的异常。
因为我们创建的数组元素时一个Integer类型，但是数组的类型是String类型，在类型转换这里，显然是很不合理的。
所以我们在创建的时候，要注意一个小的细节，在创建的时候，应该直接赋给集合数组。
ArrayList<String>[] strArr = new ArrayList[5];
然后我们将代码稍作修改：
import java.util.ArrayList;
public class Demo09 {
public static void main(String[] args) {
ArrayList<String>[] strArr = new ArrayList[5];
ArrayList<String> arr = new ArrayList<>();
arr.add("123");
strArr[0] = arr;
String s = strArr[0].get(0);
System.out.println(s);
}
}
就得到了我们想要的结果:
在创建泛型数组的时候，我们也可以根据java.lang.reflect.Array中的newInstance(Class< T>,int)来创建T[ ]数组
直接创建是显然不能创建的。
import java.lang.reflect.Array;
public class Fruit<T> {
private T[] arr;
public Fruit(Class<T> tClass , int length){
arr = (T[]) Array.newInstance(tClass,length);
}
}
创建这个泛型类保存数组：
Fruit<String> fruits = new Fruit<>(String.class, 3);
后面括号传入的是数据类型的class，和数组长度。
演示个例子：
