1、什么是泛型
泛型,即“参数化类型”。一提到参数,最熟悉的就是定义方法时有形参,然后调用此方法时有实参那么参数化类型怎么理解呢?
顾名思义,就是将类型由原来的具体的类型参数化 (动词),类似于方法中的变量参数,此时类型也定义成参数形式(可以称之为类型形参),
然后在使用 / 调用时传入具体的类型(类型实参)。
泛型的本质是为了参数化类型(在不创建新的类型的情况下,通过泛型指定的不同类型来控制形参具体限制的类型)。也就是说在泛型使用过程中。
操作的数据类型被指定为一个参数,这种参数类型可以用在类、接口和方法中,分别被称为泛型类、泛型接口、泛型方法。
参考:https://www.cnblogs.com/coprince/p/8603492.html
1.1、常见的泛型类型变量
E:元素(Element),多用于 java 集合框架
K:关键字(Key)
N:数字(Number)
T:类型(Type)
V:值(Value)
二、为什么要使用泛型
我们先来举两个例子
package com.nc.geneeric;
import java.util.ArrayList;
import java.util.List;
public class Test {
public static void main(String[] args) {
List list = new ArrayList();
list.add("泛型测试");
list.add(666);
for(int i = 0; i < list.size(); i++){
String str = (String)list.get(i);
System.out.println(str);
}
}
}
本身这个 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.nc.geneeric.test.main(test.java:17)
第二个例子,咱们来实现一个可以操作各种类型的加法,如下代码:
package com.nc.geneeric;
public class Addition {
static int add (int a, int b){
System.out.println(a + "+" + b + "=" + (a+b));
return a+b;
}
static float add (float a, float b){
System.out.println(a + "+" + b + "=" + (a+b));
return a+b;
}
static double add (double a, double b){
System.out.println(a + "+" + b + "=" + (a+b));
return a+b;
}
static <T extends Number>double addition(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(1, 2);
add(1f, 2f);
add(1d, 2d);
System.out.println("--------------------------");
addition(1, 2);
addition(1f, 2f);
addition(1d, 2d);
}
}
这个加法可以操作 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.nc.bean;
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.nc.geneeric;
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)
接口:
package com.nc.geneeric;
public interface Show<T> {
void show(T t);
}
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("泛型接口测试");
}
}
二、明确泛型接口的类型参数变量
class ShowImpl1 implements Show<String>{
@Override
public void show(String s) {
System.out.println(s);
}
public static void main(String[] args) {
ShowImpl1 showImpl = new ShowImpl1();
showImpl.show("泛型接口测试");
}
}
3.5 限定泛型类型变量
限定泛型类型上限
其实就是相当于指定了泛型类的父类声明类:类名 <泛型标识 extends 类>{}
在类中使用:
package com.nc.geneeric;
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 类> 对象名称
package com.nc.geneeric;
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();
}
}
class ShowInfo{
// 用在方法上,只能接收 Number 及其子类
public static void showInfo(Info<? extends Number> t) {
System.out.println(t);
}
public static void main(String args[]) {
Info<Integer> i1 = new Info<>();
Info<Float> i2 = new Info<>();
i1.setVar(666);
i2.setVar(666.666f);
showInfo(i1);
showInfo(i2);
}
}
限定泛型类型下限
定义对象:类名 < 泛型标识 super 类 > 对象名称
与指定上限相反,指定下限定很简单,就是相当于指定了泛型类的子类,不再赘述。
class ShowInfo{
// 只接收 String 的父类
public static void showInfo(Info<? super String> t) {
System.out.println(t);
}
public static void main(String args[]) {
Info<String> strInfo = new Info<>();
Info<Object> objInfo = new Info<>();
strInfo.setVar("限定泛型类型下限");
objInfo.setVar(new Object());
showInfo(strInfo);
showInfo(objInfo);
}
}
3.6 通配符类型
-
<? extends Parent> 指定了泛型类型的上限
-
<? super Child> 指定了泛型类型的下限
-
<?> 指定了没有限制的泛型类型
3.7 泛型擦除
泛型是提供给 javac 编译器使用的,它用于限定集合的输入类型,让编译器在源代码级别上,即挡住向集合中插入非法数据。但编译器编译完带有泛形的 java 程序后,生成的 class 文件中将不再带有泛形信息,以此使程序运行效率不受到影响,这个过程称之为 “擦除”。
3.8 泛型的使用规范
1、不能实例化泛型类
2、静态变量或方法不能引用泛型类型变量,但是静态泛型方法是可以的
3、基本类型无法作为泛型类型
4、无法使用 instanceof 关键字或 == 判断泛型类的类型
5、泛型类的原生类型与所传递的泛型无关,无论传递什么类型,原生类是一样的
6、泛型数组可以声明但无法实例化
7、泛型类不能继承 Exception 或者 Throwable
8、不能捕获泛型类型限定的异常但可以将泛型限定的异常抛出