java泛型 简书_浅析~Java泛型

1、Java中的泛型

思维导图

Java泛型.jpg

1.1、为什么要使用泛型

例如下面这个例子，如果list不加泛型，先向其添加两个String的值，再向其中添加一个Integer的值，这是完全可以的，因为这是list默认的类型是Object的；但是平时开发当中，可能忘了还传入了一个Integer的类型，就会导致如下的错误：

public static void main(String[] args) {

List list = new ArrayList();

list.add("111");

list.add("222");

list.add(333);

for (int i = 0; i < list.size(); i++) {

String value = (String) list.get(i);

System.out.println("value : " + value);

}

}

OUTPUTS

value : 111

value : 222

Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

at com.hzf.javatest.fanxing.TypeMain.main(TypeMain.java:15)

泛型的好处：

(1)适用于多种数据类型执行相同的代码

(2)泛型中的类型在使用时指定，不需要强制类型转换

1.2、泛型类和泛型接口

泛型，即“参数化类型”，只不过由具体类型的参数变为了变量参数。可以通过来表示(其他大写字母都可以，不过常用的是T、E、K、V)；这种参数类型可以用在类、接口和方法中，分别称为泛型类、泛型接口、泛型方法。

public class TypeClass {

private T data;

public T getData() {

return data;

}

public void setData(T data) {

this.data = data;

}

}

//泛型接口

public interface TypeInterface {

T next();

}

public class TypeMain implements TypeInterface{

@Override

public String next() {

return null;

}

}

1.3、泛型方法

在泛型类中的方法不一定为泛型方法，他可以用在任何地方和任何场景，包括普通类和泛型类。

泛型方法一定要在权限限定符和返回值中间加上，表明这是一个泛型方法。

public class TypeMain {

public T typeMethod(T... a) {

return a[a.length / 2];

}

public static void main(String[] args) {

TypeMain typeMain = new TypeMain();

System.out.println(typeMain.typeMethod("111", "222", "333"));

System.out.println(typeMain.typeMethod(1, 2, 3));

}

}

OUTPUTS

222

2

1.4、限定类型变量

在开发过程中，我们有时候需要对变量类型加以约束，比如比较最大值、最小值

public T min(T a, T b) {

if (a.compareTo(b) > 0) {

return a;

}

return b;

}

上面的例子程序compare再调用时，编译会出错；那么有没有一种方式可以对变量加以约束呢？我们可以使用T extends Comparable，T表示应该绑定类型的子类型，Comparable表示绑定类型，子类型和绑定类型可以是类也可以是接口。

public T min(T a, T b) {

if (a.compareTo(b) > 0) {

return a;

}

return b;

}

加以约束之后，如果在min中传入非Comparable的子类型就会报错。

extends左右都可以有多个(如 T,V extends Comparable & Serializable)，但是限定类型中，只允许有一个类，并且这个类必须是限定列表的第一个(extends 后面如果有多个，必须将类放在第一个),这种类的限定既可以用在泛型方法上也可以用在泛型类中。

2、泛型中的约束和局限性

(1)不能实例化泛型变量，例如new T()

(2)不能用基本类型实例化类型参数，例如TypeClass，只能TypeClass

(3)运行时类型查询只适用于原始类型

TypeMain typeMainString = new TypeMain<>();

TypeMain typeMainDouble = new TypeMain<>();

System.out.println(typeMainString instanceof TypeMain);

//以下两种方式都不被允许

// System.out.println(typeMainString instanceof TypeMain);

// System.out.println(typeMainString instanceof TypeMain);

System.out.println(typeMainString.getClass() == typeMainDouble.getClass());

System.out.println(typeMainDouble.getClass().getName());

OUTPUTS

true

true

com.hzf.javatest.fanxing.TypeMain

(4)不能用于静态域或者静态方法中

public class TypeMain {

private static T value;//编译报错

private T value2;//OK

public static void main(String[] args) {

T data;//编译报错

}

public void test(){

T data; //OK

}

}

之所以不能用于静态域或者静态方法中，是由于泛型是要在对象创建的时候才知道是什么类型的，而static的域早于类的构造函数，因此在这时虚拟机不知道T指的是什么

但是静态的泛型方法是可以的，因为在静态泛型方法创建的时候，不需要知道T具体指什么，当我们通过类名调用时，自然虚拟机就知道T具体的含义了。

(5)不能创建参数化类型的数组

TypeMain[] typeArrays = new TypeMain[10];//这里是编译不过的；但是如果假如这里可以

Object[] objArrays = typeArrays;//经过泛型擦除后会变成Object

Object是所有类的顶层父类，也就是typeArrays理论上就可以存放Double、Integer等其他非String的对象，那么就破坏了泛型引入的原则(规范参数)

(6)泛型类不能extends Exception或者Throwable

由于类型擦除的原因，加入泛型类可以继承自Exception的话，那么我们抛出someError和somError会统一被擦除成为somError，显然是不合适的

但是这种是可以的

public void doWork(T t) throws T {

try {

} catch (Throwable e) {

throw t;

}

}

3、泛型类型的继承规则

public static void main(String[] args) {

TypeMain typeMain = new TypeMain();

}

Apple是Fruit的子类，但是上面这行代码在编译期间就会报错，因为TypeMain和TypeMain之间没有继承关系，没有什么关系。

但是泛型类可以继承或者扩展其他的泛型类，例如List和ArrayList

public class ArrayList extends AbstractList

implements List, RandomAccess, Cloneable, java.io.Serializable

4、通配符类型

泛型的继承规则可能会导致一个问题，比如下面代码

public class TypeClass {

private T data;

public T getData() {

return data;

}

public void setData(T data) {

this.data = data;

}

}

public class TypeMain {

private static void print(TypeClass t){

System.out.println(t.getData());

}

public static void main(String[] args) {

TypeClass typeFruit = new TypeClass<>();

print(typeFruit);

TypeClass typeApple = new TypeClass<>();

print(typeApple);//这里不允许

}

}

由于print函数限定的参数只能是Fruit类型的TypeClass对象，所以即使Apple是Fruit的子类，print(typeApple也是不被允许的)，于是引入了通配符类型 ？

? extends X 表示类型的上界，类型参数是X的子类

？super X 表示类型的下界，类型参数是X的超类

4.1、？extends X

表示传递给方法的参数只能是X的子类，包括X本身

还是上面那个例子，如果把print()函数修改成

private static void print(TypeClass extends Fruit> t){

System.out.println(t.getData());

}

在使用Fruit子类类型的TypeClass传入就不会报错了。

但是当创建了TypeClass extends Fruit>对象后，我们使用这个对象的setData方法传入new Apple和new Fruit会发现编译报错

public static void main(String[] args) {

TypeClass extends Fruit> typeClass = new TypeClass<>();

typeClass.setData(new Apple());//编译报错

typeClass.setData(new Fruit());//编译报错

Fruit fruit = typeClass.getData();//OK

Apple apple = (Apple) typeClass.getData(); //OK

}

这是由于？extends X规定了上界，也就是当我们从TypeClass extends Fruit>中取元素时，编译器是可以知道取出的元素一定是Fruit或者Fruit的子类，因此getData不会报错；但是编译器不会知道setData中传入的类型具体是谁的子类，说明? extends X 可以用来安全的访问数据

4.2、？super X

表示传入的参数必须是X的超类，包括X本身

public class TypeMain {

private static void print(TypeClass super Apple> t){

System.out.println(t.getData());

}

public static void main(String[] args) {

TypeClass fruitTypeClass = new TypeClass<>();

TypeClass appleTypeClass = new TypeClass<>();

//littleApple是Apple的子类

TypeClass littleAppleTypeClass = new TypeClass<>();

print(fruitTypeClass);

print(appleTypeClass);

print(littleAppleTypeClass);//编译报错

}

}

public static void main(String[] args) {

TypeClass fruitTypeClass = new TypeClass<>();

TypeClass appleTypeClass = new TypeClass<>();

//littleApple是Apple的子类

TypeClass littleAppleTypeClass = new TypeClass<>();

TypeClass super Apple> typeClass = new TypeClass<>();

typeClass.setData(new LittleApple());

typeClass.setData(new Apple());

typeClass.setData(new Fruit());//编译报错

//getData得到的类型肯定是Apple的超类，但是具体是哪一个类不知道

//因此getData默认类是Object

Object data = typeClass.getData();

}

这里是懵逼的~ ？super Apple，规定了下界是Apple，但是为什么setData却可以传入Apple的子类型

先以getData为例，？ super Apple规定了下界，因此getData得到的类型一定是高于等于Apple的，但是具体是哪一个类型，不知道...所以编译器这里默认使用的是Object来接收getData的值；

对于setData来说，之所以设置的值只能是Apple的子类，是因为Apple的子类，比如LittleApple或者Apple自身，是可以安全的转型为Apple的，而Fruit不能够转型为Apple，通过代码来说就是

Fruit f = new Apple();

Apple apple = (Apple) new Fruit();//这行会报ClassCastException异常

因此？super X 可以安全的写入数据，可以写入X及其子类型

有哪位大神这里有更好的解释，可以随时给我留言~

5、虚拟机如何实现泛型

虚拟机实现泛型的主要原理就是类型擦除

//这段方法编译报错

private static String method(List list) {

return "";

}

private static Integer method(List list) {

return 0;

}

上述代码是不能被编译的，因为List和List编译之后都被擦除了，变成了一样的原生类型List,擦除动作导致这两种方法的特征签名变得一模一样。

由于Java泛型的引入，各种场景(虚拟机解析、反射等)下的方法调用都可能对原有的基础产生影响和新的需求，如在泛型类中如何获取传入的参数化类型等。因此，JCP组织对虚拟机规范做出了相应的修改，引入了诸如Signature、LocalVariableTypeTable等新的属性用于解决伴随泛型而来的参数类型的识别问题，Signature是其中最重要的一项属性，它的作用就是存储一个方法在字节码层面的特征签名[3]，这个属性中保存的参数类型并不是原生类型，而是包括了参数化类型的信息。修改后的虚拟机规范要求所有能识别49.0以上版本的Class文件的虚拟机都要能正确地识别Signature参数。