都2020了，还不好好学学泛型？

一、概述

Java

generics

JDK 1.5

1.1 什么是泛型？

• 泛型，即参数化类型。

一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

• 泛型的本质是为了参数化类型

在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

1.2 举个栗子：

@Test
public void genericDemo() {
List list = new ArrayList();
list.add("风尘博客");
list.add(100);

for(int i = 0; i< list.size();i++){
String item = (String)list.get(i);
log.info("item:{}", item);
}
}

毫无疑问，程序的运行结果会以崩溃结束：

java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

ArrayList

String

Integer

String

1.3 特性

1. 在编译的时候能够检查类型安全，并且所有的强制转换都是自动和隐式的；
2. 在逻辑上看以看成是多个不同的类型，实际上都是相同的基本类型。

二、泛型的使用

泛型有三种使用方式，分别为：泛型类、泛型接口、泛型方法。

2.1 泛型类

泛型类型用于类的定义中，被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。最典型的就是各种容器类，如：

List

Set

Map

2.1.1 一个最普通的泛型类:

public class Generic<T> {
/**
* key这个成员变量的类型为T,T的类型由外部指定
*/
private T key;

/**
* 泛型构造方法形参key的类型也为T，T的类型由外部指定
* @param key
*/
public Generic(T key) {
this.key = key;
}

/**
* 泛型方法getKey()的返回值类型为T，T的类型由外部指定
* @return
*/
public T getKey(){
return key;
}
}

2.1.2 泛型的使用

• 指定泛型类型

@Test
public void genericDemoWithType() {
//泛型的类型参数只能是类类型（包括自定义类），不能是简单类型，比如这里Integer改为int编译将不通过
Generic<Integer> integerGeneric = new Generic<Integer>(123456);
log.info("integerGeneric key is:{}", integerGeneric.getKey());

//传入的实参类型需与泛型的类型参数类型相同，即为String.
Generic<String> stringGeneric = new Generic<String>("风尘博客");
log.info("stringGeneric key is:{}", stringGeneric.getKey());
}

• 不指定泛型类型

如果不传入泛型类型实参的话，在泛型类中使用泛型的方法或成员变量定义的类型可以为任何的类型。

@Test
public void genericDemoWithOutType() {
Generic generic = new Generic("111111");
Generic generic1 = new Generic(4444);
Generic generic2 = new Generic(55.55);
Generic generic3 = new Generic(false);
log.info("generic key is:{}",generic.getKey());
log.info("generic1 key is:{}",generic1.getKey());
log.info("generic2 key is:{}",generic2.getKey());
log.info("generic3 key is:{}",generic3.getKey());
}

打印结果

... generic key is:111111
... generic1 key is:4444
... generic2 key is:55.55
... generic3 key is:false

2.1.3 泛型类小结

1. 泛型的类型参数只能是类类型，不能是简单类型;
2. 不能对确切的泛型类型使用

   instanceof

   操作。

2.2 泛型接口

泛型接口与泛型类的定义及使用基本相同。泛型接口常被用在各种类的生产器中，例如：

public interface Generator<T> {
public T next();
}

• 当实现泛型接口的类，未传入泛型实参时

public class FruitGenerator<T> implements Generator<T>{

public T next() {
return null;
}
}

• 当实现泛型接口的类，传入泛型实参

public class VegetablesGenerator implements Generator<String>{

private String[] vegetables = new String[]{"Potato", "Tomato"};

public String next() {
Random rand = new Random();
return vegetables[rand.nextInt(2)];
}
}

本小节示例代码地址

2.3 泛型方法

在

java

• 泛型类和泛型方法的区别

2.3.1 定义

public <T> T showKeyName(GenericMethodDemo<T> container){
return null;
}

1. 首先在

   public

   与返回值之间的

   <T>

   必不可少，这表明这是一个泛型方法，并且声明了一个泛型

   T

   ；
2. 这个

   T

   可以出现在这个泛型方法的任意位置；
3. 泛型的数量也可以为任意多个。

public class GenericMethodDemo {

/**
* 泛型类
* @param <T>
*/
public class Generic<T> {
private T key;

public Generic(T key) {
this.key = key;
}

/**
* 这里虽然在方法中使用了泛型，但是这并不是一个泛型方法，
* 这只是类中一个普通的成员方法，只不过他的返回值是在声明泛型类已经声明过的泛型，
* 所以在这个方法中才可以继续使用 T 这个泛型。
* @return
*/
public T getKey() {
return key;
}

/**
* 这才是一个真正的泛型方法
* @param container
* @param <T>
* @return
*/
public <T> T keyName(Generic<T> container){
T test = container.getKey();
return test;        }

/**
* 这也不是一个泛型方法，这就是一个普通的方法，只是使用了Generic<Number>这个泛型类做形参而已。
* @param obj
*/
public void showKeyValue1(Generic<Number> obj){

}

/**
* 这也不是一个泛型方法，这也是一个普通的方法，只不过使用了泛型通配符?
* @param obj
*/
public void showKeyValue2(Generic<?> obj){

}

/**
* 该方法编译器会报错
* 虽然我们声明了<T>,也表明了这是一个可以处理泛型的类型的泛型方法。
* 但是只声明了泛型类型T，并未声明泛型类型E，因此编译器并不知道该如何处理E这个类型。
* @param container
* @param <T>
* @return
*/
public <T> T showKeyName(Generic<E> container){
return null;
}

}
}

详见 Githu GenericMethodDemo.java

2.3.2 泛型方法的使用

泛型方法可以出现杂任何地方和任何场景中使用，但是有一种情况是非常特殊的，泛型方法出现在泛型类中。

public class GenericFruit {

class  Fruit{
@Override
public String toString() {
return "fruit";
}
}

class Apple extends Fruit{
@Override
public String toString() {
return "apple";
}
}

class Person{
@Override
public String toString() {
return "Person";
}
}

class GenerateTest<T>{

public void show_1(T t){
System.out.println(t.toString());
}

//在泛型类中声明了一个泛型方法，使用泛型E，这种泛型E可以为任意类型。可以类型与T相同，也可以不同。
//由于泛型方法在声明的时候会声明泛型<E>，因此即使在泛型类中并未声明泛型，编译器也能够正确识别泛型方法中识别的泛型。
public <E> void show_3(E t){
System.out.println(t.toString());
}

//在泛型类中声明了一个泛型方法，使用泛型T，注意这个T是一种全新的类型，可以与泛型类中声明的T不是同一种类型。
public <T> void show_2(T t){
System.out.println(t.toString());
}
}

@Test
public void test() {

Apple apple = new Apple();
Person person = new Person();

GenerateTest<Fruit> generateTest = new GenerateTest<Fruit>();
//apple是Fruit的子类，所以这里可以
generateTest.show_1(apple);
//编译器会报错，因为泛型类型实参指定的是Fruit，而传入的实参类是Person
//generateTest.show_1(person);

//使用这两个方法都可以成功
generateTest.show_2(apple);
generateTest.show_2(person);

//使用这两个方法也都可以成功
generateTest.show_3(apple);
generateTest.show_3(person);
}
}

详见 Githu GenericFruitTest.java

2.3.3 静态方法与泛型

静态方法无法访问类上定义的泛型；如果静态方法操作的引用数据类型不确定的时候，必须要将泛型定义在方法上。

如果写成如下,编译器会报错

public staticvoid show(T t){

}

• 正确写法：

public static <T> void show(T t){

}

2.3.4 泛型方法小结

泛型方法能使方法独立于类而产生变化，以下是一个基本的指导原则：

static

static

三、泛型通配符

我们在定义泛型类，泛型方法，泛型接口的时候经常会碰见很多不同的通配符，比如

T

E

K

V

3.1 常用的

T

、

E

、

K

、

V

、

？

本质上这些都是通配符，没啥区别，只不过是编码时的一种约定俗成的东西。比如上述代码中的

T

A-Z

T

T

E

K

V

？

1. ？

   ：表示不确定的

   java

   类型；

2. T (type)

   ：表示具体的一个

   java

   类型；

3. K V (key value)

   ：分别代表

   java

   键值中的

   Key

   /

   Value

   ；

4. E (element)

   ：代表

   Element

   。

3.2

?

无界通配符

对于不确定或者不关心实际要操作的类型，可以使用无限制通配符（尖括号里一个问号，即 

<?>

3.3 上界通配符

<? extends E>

extends

public void showKeyValue(Generic<? extends Number> obj){
log.info("value is {}", obj.getKey());
}

@Test
public void testForUp() {
Generic<String> generic1 = new Generic<String>("11111");
Generic<Integer> generic2 = new Generic<Integer>(2222);
Generic<Float> generic3 = new Generic<Float>(2.4f);
Generic<Double> generic4 = new Generic<Double>(2.56);

/*// 这一行代码编译器会提示错误，因为String类型并不是Number类型的子类
showKeyValue(generic1);*/

showKeyValue(generic2);
showKeyValue(generic3);
showKeyValue(generic4);
}

在类型参数中使用

extends

E

E

1. 如果传入的类型不是

   E

   或者

   E

   的子类，编译不成功；
2. 泛型中可以使用

   E

   的方法，要不然还得强转成

   E

   才能使用。

3.4 下界通配符

< ? super E>

super

Object

在类型参数中使用

super

E

E

泛型的上下边界添加，必须与泛型的声明在一起

实例代码地址

3.5

?

和

T

的区别

?

T

T

?

// 可以
T t = operate();

// 不可以
？ car = operate();

即：

T

?

3.6

Class<T>

和

Class<?>

区别

Class<T>

T

Class<?>

?

// 可以
public Class<?> clazz;

// 不可以，因为 T 需要指定类型
public Class<T> clazzT;

所以当不知道定声明什么类型的

Class

Class<?>

public Class<T> clazzT

T

public class Wildcard<T> {

public Class<?> clazz;

public Class<T> clazzT;
}

四、泛型中值得注意的地方

4.1 类型擦除

JVM

public class GenericTypeErase {

public static void main(String[] args) {
List<String> l1 = new ArrayList<String>();
List<Integer> l2 = new ArrayList<Integer>();
System.out.println(l1.getClass() == l2.getClass());

}
}

打印的结果为

true

List<String>

List<Integer>

jvm

Class

List.class

4.2 泛型类或者泛型方法中，不接受

8

种基本数据类型

需要使用它们对应的包装类。

4.3

Java

不能创建具体类型的泛型数组

List<Integer>[] li2 = new ArrayList<Integer>[];
List<Boolean> li3 = new ArrayList<Boolean>[];

List<Integer>

List<Boolean>

jvm

List<Object>

List<Integer>

List<Boolean>

4.4 强烈建议大家使用泛型

它抽离了数据类型与代码逻辑，本意是提高程序代码的简洁性和可读性，并提供可能的编译时类型转换安全检测功能。

五、总结

5.1 示例源码

Githu 示例代码

5.2 参考文章

1. java 泛型详解-绝对是对泛型方法讲解最详细的，没有之一
2. 聊一聊-JAVA 泛型中的通配符 T，E，K，V，？

5.3 技术交流

Github 示例代码

1. 风尘博客：https://www.dustyblog.cn
2. 风尘博客-掘金
3. 风尘博客-博客园
4. Github