@TryLoveCatch 2022-05-13T03:24:21.000000Z 字数 4230 阅读 360

Java知识体系之泛型

Java知识体系

Java 泛型（generics）是 JDK 5 中引入的一个新特性,泛型的本质是参数化类型，即给类型指定一个参数，然后在使用时再指定此参数具体的值，那样这个类型就可以在使用时决定了。
泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。

泛型使用方式

泛型一般有三种使用方式: 泛型类、泛型接口、泛型方法。

泛型类

//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时，必须指定T的具体类型
public class Generic<T> {
    private T key;
    public Generic(T key) {
        this.key = key;
    }
    public T getKey() {
        return key;
    }
}
// 使用
Generic<Integer> genericInteger = new Generic<Integer>(123456);

泛型接口

public interface Generator<T> {
    public T method();
}
// 实现泛型接口，不指定类型
class GeneratorImpl<T> implements Generator<T>{
    @Override
    public T method() {
        return null;
    }
}
// 实现泛型接口，指定类型：
class GeneratorImpl2 implements Generator<String>{
    @Override
    public String method() {
        return "hello";
    }
}

泛型方法

public static <E> void printArray(E[] inputArray) {
    for (E element : inputArray) {
        System.out.printf("%s ", element);
    }
    System.out.println();
}
// 创建不同类型数组： Integer, String
Integer[] intArray = { 1, 2, 3 };
String[] stringArray = { "Hello", "World" };
printArray(intArray);
printArray(stringArray);

通配符

<?>：无界通配符，即类型不确定，任意类型
<? extends T>：上边界通配符，即?是继承自T的任意子类型
<? super T>：下边界通配符，即?是T的任意父类型

// 使用 ? extends Number 表示元素的上限是 Number
// 我们无法确定具体是哪种类型的元素可以存入
// 可以确定是取出的元素类型是兼容 Number 类型的
List<? extends Number> list = new ArrayList<>();
// 编译报错
// list.add(123);
// list.add(new Object());
list.add(null);
// 只能 get, get 的对象一定是 Number 或者 Number 的子类, 那么使用 Number 是类型兼容的, 所以编译不报错
Number number = list.get(0);
// 使用 ? super Number 表示元素的下限是 Number
// 我们不能确定取出元素的类型是 Number 或 Number 的哪个父类
// 我们可以确定的是存入的元素类型是兼容 Number 或者 Number 的子类
List<? super Number> list2 = new ArrayList<>();
// Number 或者 Number 的父类无法确定具体是哪个
// 添加元素时加入 Number 的子类, 一定是类型兼容的, 所以编译不报错
list2.add(100);
list2.add(100L);
list2.add(100.0d);
// 取出元素数据类型是 Object 类, 即所有对象的父类
Object object = list2.get(0);

PECS原则

PECS 即 producer extends, Consumer super

如果想要获取, 那么推荐使用 ? extends T
如果想要存放, 那么推荐使用 ? super T

为什么有泛型？

编译期校验
避免强转
便于维护

泛型问题

泛型类中的静态方法和静态变量不可以使用泛型类所声明的泛型类型参数，例如下面的代码编译失败

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

泛型原理

协变方法逆变方法

编译器，字节码里面并没有

泛型擦除

Java 的泛型是伪泛型，只在编译期做泛型检查，运行期泛型就会消失，我们把这称为“泛型擦除”。

List<Integer> list = new ArrayList<>();
list.add(12);
//这里直接添加会报错
list.add("a");
Class<? extends List> clazz = list.getClass();
Method add = clazz.getDeclaredMethod("add", Object.class);
//但是通过反射添加是可以的
//这就说明在运行期间所有的泛型信息都会被擦掉
add.invoke(list, "kl");
System.out.println(list);

对于List<Integer>，直接添加String类型，会报错
但是通过反射添加String类型是可以的

这就说明在运行期间所有的泛型信息都会被擦掉。

还有一个经典的例子：

List<String> stringList = new ArrayList<>();
List<Integer> intList = new ArrayList<>();
System.out.println(stringList.class == intList.class);// true

Java编译器编译泛型的步骤：

检查泛型的类型，获得目标类型
擦除类型变量，并替换为限定类型（T为无限定的类型变量，用Object替换）
调用相关函数，并将结果强制转换为目标类型。

// 擦除之前 
class Pair<T> {    
    private T value;    
    public T getValue() {    
        return value;    
    }    
    public void setValue(T  value) {    
        this.value = value;    
    }    
}
// 擦除之后
class Pair {    
    private Object value;    
    public Object getValue() {    
        return value;    
    }    
    public void setValue(Object  value) {    
        this.value = value;    
    }    
}

在Pair<T>中，无边界通配符，所以用Object替换。
如果是Pair<T extends Number>，上边界通配符擦除后，类型变量用Number类型替换。
如果是Pair<T super Number>，下边界通配符擦除后，类型变量用Object类型替换。

桥方法

// 泛型接口
public interface Generic<T> {
  void test(T t);
}
// 实现类
public class SubGeneric implements Generic<String> {
  @Override
  public void test(String s) {
    System.out.println(s);
  }
}
// 使用
public class Test {
  public static void main(String[] args) {
    Generic subGeneric = new SubGeneric();
    subGeneric.test("1");
  }
}

由于类型擦除的存在，所有上例中Generic接口的test方法到JVM中会被修改为Object

public void test(Object object);

而实现类SubGeneric中的方法定义的为String类型，这似乎与父接口中的定义不同，但编译器却没报错。
main方法里面，我们使用了多态，所以调用应该是test(Object)，所以我们可以传入任何类型才对，比如说Integer类型

subGeneric.test(1);

程序可以编译成功，但是会报ClassCastException:java.lang.Integer cannot be case to java.long.String。

目前为止，这里面有两个问题：

子类与父接口的方法参数类型不一致
传入Integer编译时可以，但是运行时报错

编译器会帮我们生成一个test(Object s)的桥接方法，并且是通过强转直接调用的test(String s)，这样就能解释上面的两个问题了。

public class SubGeneric implements Generic {
  public void test(String s) {
    System.out.println(s);
  }
  public void test(Object s) {
    test((String)s);
  }
}

怎么破坏泛型

由于反射是运行时生效，而泛型类型的检查是在编译时，如果未定义上界，那么将会擦除为Object，即可以接受任意类型。所以利用反射，我们可以注入其他类型的值。

类似于上面泛型擦出的那个例子：

List<Integer> list = new ArrayList<>();
list.add(12);
//这里直接添加会报错
list.add("a");
Class<? extends List> clazz = list.getClass();
Method add = clazz.getDeclaredMethod("add", Object.class);
//但是通过反射添加是可以的
//这就说明在运行期间所有的泛型信息都会被擦掉
add.invoke(list, "kl");
System.out.println(list);

参考

https://javaguide.cn/java/basis/java-basic-questions-03.html#%E6%B3%9B%E5%9E%8B
https://segmentfault.com/a/1190000039835272
https://zhuanlan.zhihu.com/p/64585072
https://blog.csdn.net/csdn_mrsongyang/article/details/121753591
http://www.wjhsh.net/wt88-p-9624350.html