Java基础之泛型机制

轩辕琳芳 · 昨天 09:55

一、概述

Java语言作为一种静态强类型语言，在设计过程中必须平衡类型安全、灵活性以及代码的可复用性。泛型机制便是Java在1.5版本中引入的强大工具，旨在实现类型安全的集合操作及代码的通用化。

什么是泛型？为什么要使用泛型？

泛型即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。
泛型的基本设计目标，即增强类型检查和减少强制类型转换。这一设计极大地提升了代码的类型安全性，但也带来了一个重要的问题：泛型的类型参数化一旦定义，就变得非常严格，从而限制了一些灵活性。在实际项目中，往往需要解决更具通用性的问题，这时就需要Java泛型的通配符来帮助处理这些类型的不确定性。
二、泛型使用

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

2.1.1 定义

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

泛型类的最基本写法：

class 类名称 <泛型标识：可以随便写任意标识号，标识指定的泛型的类型> {
private 泛型标识 /*（成员变量类型）*/ 变量名;
//...
}

复制代码

泛型标识是任意设置的（A-Z都行），Java常见的泛型标识以及其代表含义如下：

E：代表Element元素的意思，或者Exception异常的意思。
T：代表一般的任何类。
K：代表Key的意思。
V：代表Value的意思，通常与K一起配合使用。
N：代表Number的意思。
？：表示不确定的java类型。
S：代表Subtype的意思。
S、U、V - 2nd、3rd、4th types：表示第二、第三、第四种类型。

一个最普通的泛型类：

//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时，必须指定T的具体类型
@Getter
@AllArgsConstructor
public class Generic<T> {
//key这个成员变量的类型为T，T的类型由外部指定
private T key;
}

复制代码

（2）泛型类中的静态方法和静态变量不可以使用泛型类所声明的类型参数

代码如下：

public class Test<T> {
public static T one; // 编译错误
public static T show(T one){ // 编译错误
return null;
}
}

复制代码

泛型类中的类型参数的确定是在创建泛型类对象的时候（例如ArrayList）。
而静态变量和静态方法在类加载时已经初始化，直接使用类名调用；在泛型类的类型参数未确定时，静态成员有可能被调用，因此泛型类的类型参数是不能在静态成员中使用的。

（3）静态泛型方法中可以使用自身的方法签名中新定义的类型参数（即泛型方法，后面会说到），而不能使用泛型类中定义的类型参数。

代码如下：

public class Test2<T> {
// 泛型类定义的类型参数 T 不能在静态方法中使用
public static <E> E show(E one){ // 这是正确的，因为 E 是在静态方法签名中新定义的类型参数
return null;
}
}

复制代码

（4）泛型类不只接受一个类型参数，它还可以接受多个类型参数。

代码如下：

@Getter
public class MultiType<E, T> {
E value1;
T value2;
}

复制代码

2.1.2 使用

定义的泛型类，就一定要传入泛型类型实参么？并不是这样，在使用泛型的时候如果传入泛型实参，则会根据传入的泛型实参做相应的限制，此时泛型才会起到本应起到的限制作用。如果不传入泛型类型实参的话，在泛型类中使用泛型的方法或成员变量定义的类型可以为任何的类型。

public class Main {
public static void main(String[] args) {
//泛型的类型参数只能是类类型（包括自定义类），不能是简单类型
//传入的实参类型需与泛型的类型参数类型相同，即为Integer.
Generic<Integer> genericInteger = new Generic<Integer>(123456);
//传入的实参类型需与泛型的类型参数类型相同，即为String.
Generic<String> genericString = new Generic<String>("key_value");
Generic generic = new Generic("111111");
Generic generic1 = new Generic(4444);
Generic generic2 = new Generic(55.55);
Generic generic3 = new Generic(false);
}
}

复制代码

注意：
泛型的类型参数只能是类类型，不能是简单类型。
不能对确切的泛型类型使用instanceof操作。如下面的操作是非法的，编译时会出错。

if(generic instanceof Generic<Number>) {
}

复制代码

2.2 泛型接口

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

//定义一个泛型接口
public interface Generator<T> {
T next();
}

复制代码

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

/**
* 未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
* 即：class FruitGenerator<T> implements Generator<T>{
* 如果不声明泛型，如：class FruitGenerator implements Generator<T>，编译器会报错："Unknown class"
*/
class FruitGenerator<T> implements Generator<T> {
@Override
public T next() {
return null;
}
}

复制代码

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

/**
* 传入泛型实参时：
* 定义一个生产器实现这个接口,虽然我们只创建了一个泛型接口Generator<T>
* 但是我们可以为T传入无数个实参，形成无数种类型的Generator接口。
* 在实现类实现泛型接口时，如已将泛型类型传入实参类型，则所有使用泛型的地方都要替换成传入的实参类型
* 即：Generator<T>，public T next();中的的T都要替换成传入的String类型。
*/
public class FruitGenerator implements Generator<String> {
private String[] fruits = new String[]{"Apple", "Banana", "Pear"};
@Override
public String next() {
Random rand = new Random();
return fruits[rand.nextInt(3)];
}
}

复制代码

2.3 泛型方法

在java中，泛型类的定义非常简单，但是泛型方法就比较复杂了。
尤其是我们见到的大多数泛型类中的成员方法也都使用了泛型，有的甚至泛型类中也包含着泛型方法，这样在初学者中非常容易将泛型方法理解错了。

泛型类，是在实例化类的时候指明泛型的具体类型；泛型方法，是在调用方法的时候指明泛型的具体类型。

public class Test {
public static void main(String[] args) {
Test test = new Test();
try {
Object obj = test.genericMethod(Class.forName("com.generator.test.Test"));
System.out.println(obj.getClass());
} catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
e.printStackTrace();
}
}
/**
* 泛型方法的基本介绍
* @param tClass 传入的泛型实参
* @return T 返回值为T类型
* 说明：
* 1）public 与返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。
* 2）只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
* 3）<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
* 4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。
*/
public <T> T genericMethod(Class<T> tClass) throws InstantiationException, IllegalAccessException {
T instance = tClass.newInstance();
return instance;
}
}

复制代码

2.3.1 基本用法

上面的例子可能依然会迷糊，我们再通过一个例子，把泛型方法再总结一下。

public class GenericTest {
//这个类是个泛型类，在上面已经介绍过
@Getter
@AllArgsConstructor
public class Generic<T> {
private T key;
/**
* 这个方法显然是有问题的，在编译器会给我们提示这样的错误信息"cannot reslove symbol E"
* 因为在类的声明中并未声明泛型E，所以在使用E做形参和返回值类型时，编译器会无法识别。
public E setKey(E key) {
this.key = keu
}
*/
}
/**
* 这才是一个真正的泛型方法。
* 首先在public与返回值之间的<T>必不可少，这表明这是一个泛型方法，并且声明了一个泛型T
* 这个T可以出现在这个泛型方法的任意位置.
* 泛型的数量也可以为任意多个
* 如：public <T, K> K showKeyName(Generic<T> container) {
* ...
* }
*/
public <T> T showKeyName(Generic<T> container) {
System.out.println("container key :" + container.getKey());
//当然这个例子举的不太合适，只是为了说明泛型方法的特性。
T test = container.getKey();
return test;
}
//这也不是一个泛型方法，这就是一个普通的方法，只是使用了Generic<Number>这个泛型类做形参而已。
public void showKeyValue1(Generic<Number> obj) {
System.out.println("key value is " + obj.getKey());
}
//这也不是一个泛型方法，这也是一个普通的方法，只不过使用了泛型通配符?
//同时这也印证了泛型通配符章节所描述的，?是一种类型实参，可以看做为Number等所有类的父类
public void showKeyValue2(Generic<?> obj) {
System.out.println("key value is " + obj.getKey());
}
/**
* 这个方法是有问题的，编译器会为我们提示错误信息："UnKnown class 'E' "
* 虽然我们声明了<T>,也表明了这是一个可以处理泛型的类型的泛型方法。
* 但是只声明了泛型类型T，并未声明泛型类型E，因此编译器并不知道该如何处理E这个类型。
public <T> T showKeyName(Generic<E> container) {
...
}
/**
* 这个方法也是有问题的，编译器会为我们提示错误信息："UnKnown class 'T' "
* 对于编译器来说T这个类型并未项目中声明过，因此编译也不知道该如何编译这个类。
* 所以这也不是一个正确的泛型方法声明。
public void showKey(T genericObj) {
}
*/
public static void main(String[] args) {
}
}

复制代码

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());
}
}
public static void main(String[] args) {
Apple apple = new Apple();
Person person = new Person();
GenerateTest<Fruit> generateTest = new GenerateTest<>();
//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);
}
}

复制代码

2.3.3 泛型方法与可变参数

再看一个泛型方法和可变参数的例子：

public class Test {
public static void main(String[] args) {
Test test = new Test();
test. printMsg("111", 222, "aaaa", "2323.4", 55.55);
}
public <T> void printMsg(T... args) {
for (T t : args) {
System.out.println("t is " + t);
}
}
}

复制代码

2.3.4 静态方法与泛型

静态方法有一种情况需要注意一下，那就是在类中的静态方法使用泛型：静态方法无法访问类上定义的泛型；如果静态方法操作的引用数据类型不确定的时候，必须要将泛型定义在方法上。
即：如果静态方法要使用泛型的话，必须将静态方法也定义成泛型方法。

public class StaticGenerator<T> {
//...
/**
* 如果在类中定义使用泛型的静态方法，需要添加额外的泛型声明（将这个方法定义成泛型方法）
* 即使静态方法要使用泛型类中已经声明过的泛型也不可以。
* 如：public static void show(T t){..},此时编译器会提示错误信息：
"StaticGenerator cannot be refrenced from static context"
*/
public static <T> void show(T t) {
}
}

复制代码

2.3.5 总结

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

无论何时，如果你能做到，你就该尽量使用泛型方法。

也就是说，如果使用泛型方法将整个类泛型化，那么就应该使用泛型方法。另外对于一个static的方法而已，无法访问泛型类型的参数。所以如果static方法要使用泛型能力，就必须使其成为泛型方法。
三、类型擦除

3.1 定义

泛型的本质是将数据类型参数化，它通过擦除的方式来实现，即编译器会在编译期间擦除代码中的所有泛型语法并相应的做出一些类型转换动作。
换而言之，泛型信息只存在于代码编译阶段，在代码编译结束后，与泛型相关的信息会被擦除掉，专业术语叫做类型擦除。也就是说，成功编译过后的class文件中不包含任何泛型信息，泛型信息不会进入到运行时阶段。
其实Java中的泛型本质是伪泛型
当把集合定义为string类型的时候，当数据添加在集合当中的时候，仅仅在门口检查了一下数据是否符合String类型，如果是String类型，就添加成功，当添加成功以后，集合还是会把这些数据当做Object类型处理，当往外获取的时候，集合在把他强转String类型

当代码编译到class文件的时候，泛型就消失，叫泛型的擦除

看一个例子，假如我们给ArrayList集合传入两种不同的数据类型，并比较它们的类信息。

public class GenericType {
public static void main(String[] args) {
ArrayList<String> arrayString = new ArrayList<>();
ArrayList<Integer> arrayInteger = new ArrayList<>();
System.out.println(arrayString.getClass() == arrayInteger.getClass());// true
}
}

复制代码

在这个例子中，我们定义了两个ArrayList集合，不过一个是ArrayList，只能存储字符串。一个是ArrayList，只能存储整型对象。我们通过arrayString对象和arrayInteger对象的getClass()方法获取它们的类信息并比较，发现结果为true。
明明我们在中传入了两种不同的数据类型，那为什么它们的类信息还是相同呢？这是因为，在编译期间，所有的泛型信息都会被擦除，ArrayList和ArrayList类型，在编译后都会变成ArrayList类型。
那么是不是所有的类型参数被擦除后都以Object类进行替换呢？
答案是否定的，大部分情况下，类型参数T被擦除后都会以Object类进行替换；而有一种情况则不是，那就是使用到了extends和super语法的有界类型参数(即泛型通配符)
3.2 原理

假如我们定义了一个ArrayList泛型集合，若向该集合中插入String类型的对象，不需要运行程序，编译器就会直接报错。这里可能有小伙伴就产生了疑问：

不是说泛型信息在编译的时候就会被擦除掉吗？那既然泛型信息被擦除了，如何保证我们在集合中只添加指定的数据类型的对象呢？
换而言之，我们虽然定义了ArrayList泛型集合，但其泛型信息最终被擦除后就变成了ArrayList集合，那为什么不允许向其中插入String对象呢？

Java是如何解决这个问题的？
其实在创建一个泛型类的对象时，Java编译器是先检查代码中传入的数据类型，并记录下来，然后再对代码进行编译，编译的同时进行类型擦除；如果需要对被擦除了泛型信息的对象进行操作，编译器会自动将对象进行类型转换。

可以把泛型的类型安全检查机制和类型擦除想象成演唱会的验票机制：以ArrayList泛型集合为例。

当我们在创建一个ArrayList泛型集合的时候，ArrayList可以看作是演唱会场馆，而就是场馆的验票系统，Integer是验票系统设置的门票类型；

当验票系统设置好为后，只有持有Integer门票的人才可以通过验票系统，进入演唱会场馆（集合）中；若是未持有Integer门票的人想进场，则验票系统会发出警告（编译器报错）。

在通过验票系统时，门票会被收掉（类型擦除），但场馆后台（JVM）会记录下观众信息（泛型信息）。

进场后的观众变成了没有门票的普通人（原始数据类型）。但是，在需要查看观众的信息时（操作对象），场馆后台可以找到记录的观众信息（编译器会自动将对象进行类型转换）。

举例如下：

public class GenericType {
public static void main(String[] args) {
ArrayList<Integer> arrayInteger = new ArrayList<>();// 设置验票系统
arrayInteger.add(111);// 观众进场，验票系统验票，门票会被收走（类型擦除）
Integer n = arrayInteger.get(0);// 获取观众信息，编译器会进行强制类型转换
System.out.println(n);
// Integer n = arrayInteger.get(0); 这条代码底层如下：
//（1）get()方法的返回值返回的是Object类型
//Object object = arrayInteger.get(0);
//（2）编译器自动插入Integer的强制类型转换
//Integer n = (Integer) object;
}
}

复制代码

擦除ArrayList的泛型信息后，get()方法的返回值将返回Object类型，但编译器会自动插入Integer的强制类型转换。也就是说，编译器把get()方法调用翻译为两条字节码指令：

对原始方法get()的调用，返回的是Object类型；
将返回的Object类型强制转换为Integer类型；

3.3 小结

1.泛型信息（包括泛型类、接口、方法）只在代码编译阶段存在，在代码成功编译后，其内的所有泛型信息都会被擦除，并且类型参数T会被统一替换为其原始类型（默认是Object类，若有extends或者super则另外分析）；
2.在泛型信息被擦除后，若还需要使用到对象相关的泛型信息，编译器底层会自动进行类型转换（从原始类型转换为未擦除前的数据类型）。
四、泛型通配符

4.1 泛型的继承

在介绍泛型通配符之前，先提出一个问题，在Java的多态中，我们知道可以将一个子类对象赋值给其父类的引用，这也叫向上转型。
举例如下：

public class GenericType {
public static void main(String[] args) {
List list = new ArrayList();
}
}

复制代码

上面的代码很好得体现了Java的多态特性。
在Java标准库中的集合ArrayList类实现了List接口，其源码大致如下：

public class ArrayList<T> implements List<T> {
//...
}

复制代码

那现在我们思考一个问题，在ArrayList泛型集合中，当传入中的数据类型相同时，是否还能将一个ArrayList对象赋值给其父类的引用List。
代码如下：

public class GenericType {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
}
}

复制代码

上面的代码没有问题，即ArrayList对象可以向上转型为List，但两者传入中的数据类型必须相同。
继续思考一个问题，已知Integer类是Number类的子类，那如果ArrayList泛型集合中，在之间使用向上转型，也就是将ArrayList对象赋值给List的引用，是否被允许呢？
举例如下：

public class GenericType {
public static void main(String[] args) {
List<Number> list01 = new ArrayList<Integer>();// 编译错误
ArrayList<Number> list02 = new ArrayList<Integer>();// 编译错误
}
}

复制代码

上面代码会报错，我们发现并不能把ArrayList对象赋值给List的引用，甚至不能把ArrayList对象赋值给ArrayList的引用。这也说明了在一般泛型中，不能向上转型。
这是为什么？如果我们假设ArrayList可以向上转型为ArrayList。
观察下面代码：

public class GenericType {
public static void main(String[] args) {
// 创建一个ArrayList<Integer>集合
ArrayList<Integer> integerList = new ArrayList<>();
// 添加一个Integer对象
integerList.add(new Integer(123));
// “向上转型”为ArrayList<Number>
ArrayList<Number> numberList = integerList;
// 添加一个Float对象，Float也是Number的子类，编译器不报错
numberList.add(new Float(12.34));
// 从ArrayList<Integer>集合中获取索引为1的元素（即添加的Float对象）：
Integer n = integerList.get(1); // ClassCastException，运行出错
}
}

复制代码

当我们把一个ArrayList向上转型为ArrayList类型后，这个ArrayList集合就可以接收Float对象了，因为Float类是Number类的子类。
但是，ArrayList实际上和ArrayList是同一个集合，而在泛型的定义中，ArrayList集合是不可以接收Float对象的。这是因为，在使用get()方法获取集合元素的时候，编译器会自动将Float对象强转成Integer对象，而这会产生ClassCastException异常。
正因如此，编译器为了避免发生这种错误，根本就不允许把ArrayList对象向上转型为ArrayList；换而言之，ArrayList和ArrayList两者之间没有继承关系。
4.2 泛型通配符的引入

我们上面讲到了泛型的继承关系，ArrayList不是ArrayList的子类。
（1）先看一个问题：假设我们定义了一个Pair类，如下：

@Getter
@Setter
@AllArgsConstructor
public class Pair<T> {
private T first;
private T last;
}

复制代码

（2）然后，我们针对Pair类型写了一个静态方法，它接收的参数类型是Pair。
代码如下：

public class PairHelper {
static int addPair(Pair<Number> p) {
Number first = p.getFirst();
Number last = p.getLast();
return first.intValue() + last.intValue();
}
}

复制代码

（3）在测试类中创建一个Pair对象，并调用addPair()方法。
代码如下：

public class Main {
public static void main(String[] args) {
Pair<Number> pair = new Pair<>(1, 2);
int sum = PairHelper.addPair(pair);
}
}

复制代码

（4）上面的代码正常编译运行。但我们发现，在实际创建Pair对象的时候，我们传入的实参(1,2)实际上是Integer类型；那我们是否可以直接创建一个Pair对象，并将其传给add()方法呢？
代码如下：

public class Main {
public static void main(String[] args) {
Pair<Integer> pairInteger = new Pair<>(123, 456);
int sum = PairHelper.addPair(pairInteger);
}
}

复制代码

编译器会直接报错，原因是Pair并不是Pair的子类，而addPair()方法的形参数据类型为Pair。因此，Pair对象不能传给addPair()方法。
那有没有办法使得addPair()方法可以接收Pair对象？总不能重新定义一个新的addPair()方法来处理Pair对象吧，这显然与Java中的多态理念相违背。
因此我们需要一个在逻辑上可以表示为Pair和Pair这两者的父类引用类型，由此，泛型通配符便应运而生。
4.3 泛型通配符定义

在现实编码中，确实有这样的需求，希望泛型能够处理某一类型范围内的类型参数，比如某个泛型类和它的子类，为此Java引入了泛型通配符这个概念。
泛型通配符有3种形式：
<ul>：被称作无限定的通配符。
在逻辑上表示为所有数据类型的父类，它可以代表ArrayList、ArrayList、ArrayList中的某一个集合，但实质上它们之间没有继承关系。</p>举例如下：

public class GenericType {
public static void main(String[] args) {
ArrayList<Number> list01 = new ArrayList<Integer>();// 编译错误
ArrayList<? extends Number> list02 = new ArrayList<Integer>();// 编译正确
}
}

复制代码

上述代码是可以正常编译运行的，因为ArrayList在逻辑上是ArrayList的父类，可以安全地向上转型。
（2）ArrayList既没有上界也没有下界，因此，它可以代表所有数据类型的某一个集合，但我们不能指定ArrayList的数据类型。
举例如下：

public class GenericType {
public static void main(String[] args) {
ArrayList<? extends Number> list = new ArrayList<>();
list.add(new Integer(1));// 编译错误
list.add(new Float(1.0));// 编译错误
}
}

复制代码

ArrayList集合的数据类型是不确定的，因此我们只能往集合中添加null；而我们从ArrayList集合中取出的元素，也只能赋值给Object对象，不然会产生ClassCastException异常（原因可以结合上界和下界通配符理解）。
（3）大多数情况下，可以用类型参数代替通配符。
举例如下：

// 改写前
public class PairHelper {
static int addPair(Pair<Number> p) {
Number first = p.getFirst();
Number last = p.getLast();
return first.intValue() + last.intValue();
}
}
// 改写后
public class PairHelper {
static int addPair(Pair<? extends Number> p) {
Number first = p.getFirst();
Number last = p.getLast();
return first.intValue() + last.intValue();
}
}

复制代码

4.7 协变与逆变对比

（1）对于[] ls2 = new ArrayList[10]; List[] ls3 = new ArrayList[10]; //下面采用通配符的方式是被允许的: 数组的类型不可以是类型变量， // 除非是采用通配符的方式，因为对于通配符的方式，最后取出数据是要做显式的类型转换的。 List[] lsa = new List[10]; // OK, array of unbounded wildcard type. Object o = lsa; Object[] oa = (Object[]) o; List li = new ArrayList(); li.add(new Integer(3)); oa[1] = li; // Correct. Integer i = (Integer) lsa[1].get(0); // OK System.out.println(i); }}[/code]这种情况下，由于JVM泛型的擦除机制，在运行时JVM是不知道泛型信息的，所以可以给oa[1]赋上一个ArrayList而不会出现异常，但是在取出数据的时候却要做一次类型转换，所以就会出现ClassCastException，如果可以进行泛型数组的声明，上面说的这种情况在编译期将不会出现任何的警告和错误，只有在运行时才会出错。
而对泛型数组的声明进行限制，对于这样的情况，可以在编译期提示代码有类型安全问题，比没有任何提示要强很多。
五、总结

本文中的例子主要是为了阐述泛型中的一些思想而简单举出的，并不一定有着实际的可用性。另外，一提到泛型，相信大家用到最多的就是在集合中，其实，在实际的编程过程中，自己可以使用泛型去简化开发，且能很好的保证代码质量。
参考

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

账号		自动登录	找回密码
密码			立即注册

Java基础之泛型机制

浏览过的版块

签约作者