参考文献---Java 基础（一）| 使用泛型的正确姿势
前言
为跳槽面试做准备，今天开始进入 Java 基础的复习。希望基础不好的同学看完这篇文章，能掌握泛型，而基础好的同学权当复习，希望看完这篇文章能够起一点你的青涩记忆。
一、什么是泛型
泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？
顾名思义，就是将类型由原来的具体的类型参数化(动词)，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），
然后在使用/调用时传入具体的类型（类型实参）。
泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中。
操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。
参考：https://www.cnblogs.com/coprince/p/8603492.html
1.1常见的泛型类型变量：
E：元素（Element），多用于 java 集合框架
K：关键字（Key）
N：数字（Number）
T：类型（Type）
V：值（Value）
二、为什么要使用泛型
回答这个问题前，首先举两个栗子，我想打印字符串到控制台，如下代码：
package com.nasus.generic;
import java.util.ArrayList;
import java.util.List;
/**
* Project Name:review_java <br/>
* Package Name:com.nasus.generic <br/>
* Date:2019/12/28 20:58 <br/>
*
* @author <a href="turodog@foxmail.com">chenzy</a><br/>
*/
public class Show {
public static void main(String[] args) {
List list=new ArrayList();
list.add("一个优秀的废人");
list.add("java 工程师");
list.add(666);
for (int i = 0; i < list.size(); i++) {
String value= (String) list.get(i);
System.out.println(value);
}
}
}
本身我的 list 是打算装载 String 去打印的，但是大家发现没有？我传入 int 型时（编译期），Java 是没有任何提醒的（顶多是 IDEA 警告）。直到我循环调用（运行期）打印方法，打印 int 型时，Java 才报错：
Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
一个优秀的废人
at com.nasus.generic.Show.main(Show.java:23)
java 工程师
第二栗子，我想实现一个可以操作各种类型的加法，如下代码：
package com.nasus.generic.why;
/**
* Project Name:review_java <br/>
* Package Name:com.nasus.generic <br/>
* Date:2019/12/28 21:18 <br/>
*
* @author <a href="turodog@foxmail.com">chenzy</a><br/>
*/
public class Add {
private static int add(int a, int b) {
System.out.println(a + "+" + b + "=" + (a + b));
return a + b;
}
private static float add(float a, float b) {
System.out.println(a + "+" + b + "=" + (a + b));
return a + b;
}
private static double add(double a, double b) {
System.out.println(a + "+" + b + "=" + (a + b));
return a + b;
}
// 一个泛型方法
private static <T extends Number> double add(T a, T b) {
System.out.println(a + "+" + b + "=" + (a.doubleValue() + b.doubleValue()));
return a.doubleValue() + b.doubleValue();
}
public static void main(String[] args) {
Add.add(1, 2);
Add.add(1f, 2f);
Add.add(1d, 2d);
System.out.println("--------------------------");
// 以下三个都是调用泛型方法
Add.add(Integer.valueOf(1), Integer.valueOf(2));
Add.add(Float.valueOf(1), Float.valueOf(2));
Add.add(Double.valueOf(1), Double.valueOf(2));
}
}
这个加法可以操作 int、float、double 类型，但相应的也必须重写对应的加法，而此时我其实可以就用一个泛型方法就实现了上面三个重载方法的功能。
1+2=3
1.0+2.0=3.0
1.0+2.0=3.0
--------------------------
1+2=3.0
1.0+2.0=3.0
1.0+2.0=3.0
所以使用泛型原因有三个：
提高可读性
使 ClassCastException 这种错误在编译期就检测出来
适用于多种数据类型执行相同的代码（代码复用）
参考：https://www.jianshu.com/p/986f732ed2f1
三、泛型详解
3.1泛型类
由我们指定想要传入泛型类中的类型，把泛型定义在类上，用户使用该类的时候，才把类型明确下来，比如：定义一个万能的实体数据暂存工具类。
注意：泛型类在初始化时就把类型确定了
package com.nasus.generic.how;
/**
* Project Name:review_java <br/>
* Package Name:com.nasus.generic.how <br/>
* Date:2019/12/28 21:35 <br/>
*
* @author <a href="turodog@foxmail.com">chenzy</a><br/>
*/
public class EntityTool<T> {
private T entity;
public T getEntity() {
return entity;
}
public void setEntity(T entity) {
this.entity = entity;
}
public static void main(String[] args) {
// 创建对象并指定元素类型
EntityTool<String> stringTool = new EntityTool<>();
stringTool.setEntity("一个优秀的废人");
String s = stringTool.getEntity();
System.out.println(s);
// 创建对象并指定元素类型
EntityTool<Integer> integerTool = new EntityTool<>();
// 此时，如果这里传入的还是 String 类型，那就会在编译期报错
integerTool.setEntity(10);
int i = integerTool.getEntity();
System.out.println(i);
}
}
3.2泛型方法
有时候我们只想在方法中使用泛型，可以这么定义：
值得注意的是：
与泛型类不同，泛型方法在调用时才确定最终类型
若有返回值，返回值不需要强转
package com.nasus.generic.how;
/**
* Project Name:review_java <br/>
* Package Name:com.nasus.generic.how <br/>
* Date:2019/12/28 21:46 <br/>
*
* @author <a href="turodog@foxmail.com">chenzy</a><br/>
*/
public class Show {
public static <T> T show(T t) {
System.out.println(t);
return t;
}
public static void main(String[] args) {
// 返回值不用强转，传进去是什么，返回就是什么
String s = show("一个优秀的废人");
int num1 = show(666);
double num2 = show(666.666);
System.out.println("------------------------");
System.out.println(s);
System.out.println(num1);
System.out.println(num2);
}
}
3.3泛型接口
泛型接口分两种实现方法：
一是实现类不明确泛型接口的类型参数变量，这时实现类也必须定义类型参数变量（比如下面 Showimpl）
接口：
public interface Show<T> {
void show(T t);
}
public class ShowImpl<T> implements Show<T>{
@Override
public void show(T t) {
System.out.println(t);
}
public static void main(String[] args) {
ShowImpl<String> stringShow = new ShowImpl<>();
stringShow.show("一个优秀的废人");
}
}
二是明确泛型接口的类型参数变量
public class ShowImpl2 implements Show<String>{
@Override
public void show(String s) {
System.out.println("一个优秀的废人");
}
}
3.5 限定泛型类型变量
限定泛型类型上限
其实就是相当于指定了泛型类的父类
声明类：类名<泛型标识 extends 类>{}
在类中使用：
// 用在类上
public class Show<T extends Number> {
private T show(T t){
System.out.println(t);
return t;
}
public static void main(String[] args) {
// 初始化时指定类型
Show<Integer> show = new Show<>();
show.show(6666666);
// 报错，该类只接受继承于 Number 的泛型参数
// Show<String> stringShow = new Show<>();
}
}
方法中使用：
定义对象：类名<泛型标识 extends 类> 对象名称
public class Info<T> {
// 定义泛型变量
private T var;
public void setVar(T var) {
this.var = var;
}
public T getVar() {
return this.var;
}
public String toString() {
return this.var.toString();
}
}
public class ShowInfo {
// 用在方法上，只能接收 Number 及其子类
public static void showInfo(Info<? extends Number> t) {
System.out.print(t);
}
public static void main(String args[]) {
Info<Integer> i1 = new Info<>();
Info<Float> i2 = new Info<>();
i1.setVar(666666666);
i2.setVar(666666.66f);
showInfo(i1);
showInfo(i2);
}
}
限定泛型类型下限
定义对象：类名<泛型标识 extends 类> 对象名称
与指定上限相反，指定下限定很简单，就是相当于指定了泛型类的子类，不再赘述。
public class ShowInfo {
// 只接受 String 的父类
public static void showInfo(Info<? super String> t) {
System.out.println(t);
}
public static void main(String args[]) {
Info<String> stringInfo = new Info<>();
Info<Object> objectInfo = new Info<>();
stringInfo.setVar("一个优秀的废人");
objectInfo.setVar(new Object());
showInfo(stringInfo);
showInfo(objectInfo);
}
}
3.6 通配符类型
<? extends Parent> 指定了泛型类型的上限
<? super Child> 指定了泛型类型的下届
<?> 指定了没有限制的泛型类型
3.7 泛型擦除
泛型是提供给 javac 编译器使用的，它用于限定集合的输入类型，让编译器在源代码级别上，即挡住向集合中插入非法数据。但编译器编译完带有泛形的 java 程序后，生成的 class 文件中将不再带有泛形信息，以此使程序运行效率不受到影响，这个过程称之为 “擦除”。
3.8 泛型的使用规范
1、不能实例化泛型类
2、静态变量或方法不能引用泛型类型变量，但是静态泛型方法是可以的
3、基本类型无法作为泛型类型
4、无法使用 instanceof 关键字或 == 判断泛型类的类型
5、泛型类的原生类型与所传递的泛型无关，无论传递什么类型，原生类是一样的
6、泛型数组可以声明但无法实例化
7、泛型类不能继承 Exception 或者 Throwable
8、不能捕获泛型类型限定的异常但可以将泛型限定的异常抛出
3.9 虚拟机是如何实现泛型的 (JAVA:类型擦除 C++:类型膨胀)
泛型思想早在C++语言的模板（Template）中就开始生根发芽，在Java语言处于还没有出现泛型的版本时，只能通过Object是所有类型的父类和类型强制转换两个特点的配合来实现类型泛化。，由于Java语言里面所有的类型都继承于java.lang.Object，所以Object转型成任何对象都是有可能的。但是也因为有无限的可能性，就只有程序员和运行期的虚拟机才知道这个Object到底是个什么类型的对象。在编译期间，编译器无法检查这个Object的强制转型是否成功，如果仅仅依赖程序员去保障这项操作的正确性，许多ClassCastException的风险就会转嫁到程序运行期之中。
泛型技术在C#和Java之中的使用方式看似相同，但实现上却有着根本性的分歧，C#里面泛型无论在程序源码中、编译后的IL中（Intermediate Language，中间语言，这时候泛型是一个占位符），或是运行期的CLR中，都是切实存在的，List＜int＞与List＜String＞就是两个不同的类型，它们在系统运行期生成，有自己的虚方法表和类型数据，这种实现称为类型膨胀，基于这种方法实现的泛型称为真实泛型。
Java语言中的泛型则不一样，它只在程序源码中存在，在编译后的字节码文件中，就已经替换为原来的原生类型（Raw Type，也称为裸类型）了，并且在相应的地方插入了强制转型代码，因此，对于运行期的Java语言来说，ArrayList＜int＞与ArrayList＜String＞就是同一个类，所以泛型技术实际上是Java语言的一颗语法糖，Java语言中的泛型实现方法称为类型擦除，基于这种方法实现的泛型称为伪泛型。
将一段Java代码编译成Class文件，然后再用字节码反编译工具进行反编译后，将会发现泛型都不见了，程序又变回了Java泛型出现之前的写法，泛型类型都变回了原生类型
上面这段代码是不能被编译的，因为参数List＜Integer＞和List＜String＞编译之后都被擦除了，变成了一样的原生类型List＜E＞，擦除动作导致这两种方法的特征签名变得一模一样。
由于Java泛型的引入，各种场景（虚拟机解析、反射等）下的方法调用都可能对原有的基础产生影响和新的需求，如在泛型类中如何获取传入的参数化类型等。因此，JCP组织对虚拟机规范做出了相应的修改，引入了诸如Signature、LocalVariableTypeTable等新的属性用于解决伴随泛型而来的参数类型的识别问题，Signature是其中最重要的一项属性，它的作用就是存储一个方法在字节码层面的特征签名[3]，这个属性中保存的参数类型并不是原生类型，而是包括了参数化类型的信息。修改后的虚拟机规范要求所有能识别49.0以上版本的Class文件的虚拟机都要能正确地识别Signature参数。
另外，从Signature属性的出现我们还可以得出结论，擦除法所谓的擦除，仅仅是对方法的Code属性中的字节码进行擦除，实际上元数据中还是保留了泛型信息，这也是我们能通过反射手段取得参数化类型的根本依据。
网友评论