一、泛型介绍
1、简介
Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许开发者在编译时检测到非法的类型
参数化类型:
- 把类型当作是参数一样传递
**<数据类型>**只能是引用类型
相关术语：
ArrayList<E>中的E称为类型参数变量ArrayList<Integer>中的Integer称为实际类型参数- 整个称为
ArrayList<E>泛型类型 - 整个
ArrayList<Integer>称为参数化的类型ParameterizedType
2、泛型优点
- 类型安全。 泛型的主要目标是提高 Java 程序的类型安全。通过知道使用泛型定义的变量的类型限制，编译器可以在一个高得多的程度上验证类型假设。没有泛型，这些假设就只存在于程序员的头脑中（或者如果幸运的话，还存在于代码注释中）。
- 消除强制类型转换。 泛型的一个附带好处是，消除源代码中的许多强制类型转换。这使得代码更加可读，并且减少了出错机会。
- 潜在的性能收益。 泛型为较大的优化带来可能。在泛型的初始实现中，编译器将强制类型转换（没有泛型的话，程序员会指定这些强制类型转换）插入生成的字节码中。但是更多类型信息可用于编译器这一事实，为未来版本的 JVM 的优化带来可能。由于泛型的实现方式，支持泛型（几乎）不需要 JVM 或类文件更改。所有工作都在编译器中完成，编译器生成类似于没有泛型（和强制类型转换）时所写的代码，只是更能确保类型安全而已。
3、泛型的定义和使用
- 泛型类
- 泛型方法
- 泛型接口
二、泛型基础
1、泛型类与泛型方法
1、泛型类
**泛型类就是把泛型定义在类上，用户使用该类的时候，才把类型明确下来。**这样的话，用户明确了什么类型，该类就代表着什么类型；用户在使用的时候就不用担心强转的问题，运行时转换异常的问题了。
public class test {
public static void main(String[] args) {
//创建对象并指定元素类型
User<String> tool = new User<>();
tool.setObj("shawn");
String s = tool.getObj();
System.out.println(s);
//创建对象并指定元素类型
User<Integer> objectTool = new User<>();
//如果我在这个对象里传入的是String类型的,它在编译时期就通过不了了.
objectTool.setObj(10);
int i = objectTool.getObj();
System.out.println(i);
}
/*
1:把泛型定义在类上
2:类型变量定义在类上,方法中也可以使用
*/
public static class User<T> {
private T obj;
public T getObj() {
return obj;
}
public void setObj(T obj) {
this.obj = obj;
}
}
}
2、泛型方法
泛型方法与泛型类稍有不同的地方是，类型参数也就是尖括号那一部分是写在返回值前面的。第一个 T 被称为类型参数，而方法中的 T 被称为参数化类型，它不是运行时真正的参数。最后声明的类型参数，其实也是可以当作返回值的类型的。
public class Test1 {
//定义泛型方法
public <T> T void testMethod(T t){
// TODO
return null;
}
}
3、泛型类和泛型方法并存
public class test {
public static void main(String[] args) {
Test1<String> t = new Test1();
t.testMethod("shawn");
//注意使用泛型方法并不需要我们显式地用<>声明类型
Integer i = t.testMethod1(new Integer(1));
// 1
System.out.println(i);
}
// 泛型类和泛型方法并存，两者的类型参数最好不要同名
public static class Test1<T>{
public void testMethod(T t){
// java.lang.String
System.out.println(t.getClass().getName());
}
public <E> E testMethod1(E e){
return e;
}
}
}
2、泛型继承关系
泛型类是拥有泛型这个特性的类，它本质上还是一个Java类，那么它就可以被继承。泛型继承分两种情况
- 子类明确泛型类的类型参数变量
- 子类不明确泛型类的类型参数变量
要注意的是实现类的要是重写父类的方法，返回值的类型是要和父类一样的；其次类上声明的泛形只对非静态成员有效
public class test {
public static void main(String[] args) {
//测试第一种情况
Inter<String> i = new InterImpl();
i.show("hello");
//第二种情况测试
Inter<String> ii = new InterImpl1<>();
ii.show("100");
}
/**
把泛型定义在接口上
*/
public interface Inter<T> {
void show(T t);
}
/**
* 子类明确泛型类的类型参数变量
*/
public static class InterImpl implements Inter<String> {
@Override
public void show(String s) {
System.out.println(s);
}
}
/**
* 当子类不明确泛型类的类型参数变量时，外界使用子类的时候
* 也需要传递类型参数变量进来，
* 在实现类上需要定义出类型参数变量
*/
public static class InterImpl1<T> implements Inter<T> {
@Override
public void show(T t) {
System.out.println(t);
}
}
}
3、泛型通配符
1、介绍
**常用的 T，E，K，V，？**本质上都是通配符，没啥区别，只不过是编码时的一种约定俗成的东西。比如代码中的 T ，我们可以换成 A-Z 之间的任何一个 字母都可以，并不会影响程序的正常运行，但是如果换成其他的字母代替 T ，在可读性上可能会弱一些。通常情况下，T，E，K，V，？是这样约定的：
- ？表示不确定的 java 类型
- T (type) 表示具体的一个java类型
- K V (key value) 分别代表java键值中的Key Value
- E (element) 代表Element
2、？无界通配符
对于不确定或者不关心实际要操作的类型，可以使用无限制通配符（尖括号里一个问号，即 <?> ），表示可以持有任何类型。无限定通配符经常与容器类配合使用，它其中的 ? 其实代表的是未知类型，所以涉及到 ? 时的操作，一定与具体类型无关。
3、上界通配符 < ? extends E>
上届：用 extends 关键字声明，表示参数化的类型可能是所指定的类型，或者是此类型的子类。
在类型参数中使用 extends 表示这个泛型中的参数必须是 E 或者 E 的子类，这样有两个好处：
- 如果传入的类型不是 E 或者 E 的子类，编译不成功
- 泛型中可以使用 E 的方法，要不然还得强转成 E 才能使用
public class test {
public class Test2 <T,E extends T>{
T value1;
E value2;
}
public <D,S extends D> void test(D d,S s){
// TODO
}
}
4、下界通配符 < ? super E>
下界: 用 super 进行声明，表示参数化的类型可能是所指定的类型，或者是此类型的父类型，直至 Object
在泛型的上限和下限中有一个原则：PECS(Producer Extends Consumer Super)
- 带有子类限定的可以从泛型读取【也就是—>(? extend T)】-------->Producer Extends
- 带有超类限定的可以从泛型写入【也就是—>(? super T)】-------->Consumer Super
5、通配符?和泛型方法T区别
使用原则：
- 如果参数之间的类型有依赖关系，或者返回值是与参数之间有依赖关系的。那么就使用泛型方法
- 如果没有依赖关系的，就使用通配符，通配符会灵活一些.
//大多时候，我们都可以使用泛型方法来代替通配符
//使用通配符
public static void test(List<?> list) {
}
//使用泛型方法
public <T> void test2(List<T> t) {
}
两者区别：
- 通过 T 来 确保 泛型参数的一致性
- 类型参数可以多重限定而通配符不行
- 通配符可以使用超类限定而类型参数不行
//类型参数 T 只具有 一种 类型限定方式：
//但是通配符 ? 可以进行 两种限定：
T extends A
? extends A
? super A
三、泛型与虚拟机
1、类型擦除
泛型是 Java 1.5 版本才引进的概念，但是泛型代码能够很好地和之前版本的代码很好地兼容。这是因为泛型是提供给javac编译器使用的，它用于限定集合的输入类型，让编译器在源代码级别上，即挡住向集合中插入非法数据。但编译器编译完带有泛形的java程序后，生成的class文件中将不再带有泛形信息，以此使程序运行效率不受到影响，这个过程称之为“擦除”。
public class test {
public static void main(String[] args){
List<String> list = new ArrayList<>();
List<Integer> list1 = new ArrayList<>();
// 结果为True,因为结果都为List
System.out.println(list.getClass()==list1.getClass());
}
}
类型擦除过程中，原始类型用第一个限定来替换类型变量，如果没有给定限定，就替换为Object。例如User<T>中的类型变量没有显示的限定，就会用Object进行替换；如果声明了User<T extends Comparable>，就会用Comparable替换。
2、泛型转换重要结论
- 虚拟机中没有泛型，只有普通的类和方法
- 所有的类型参数都会替换为它们的限定类型
- 会合成桥方法来保持多态
- 为保持类型安全性，必要时会插人强制类型转换
3、泛型局限性
- 不能使用基本类型实例化类型参数
- 不能实例化类型参数
- 不可以实例化类型变量的数组
- 不可以定义泛型类的数组
- 不可以对泛型类型进行类型检测/转化
- 不可以抛出或捕获泛型异常
- 泛型类的静态类型变量/方法无效
- 类型擦除引发的冲突
