@TryLoveCatch
2022-05-13 11:24
字数 4230
阅读 550
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 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 即 producer extends, Consumer super
泛型类中的静态方法和静态变量不可以使用泛型类所声明的泛型类型参数,例如下面的代码编译失败
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<String> stringList = new ArrayList<>();
List<Integer> intList = new ArrayList<>();
System.out.println(stringList.class == intList.class);// true
Java编译器编译泛型的步骤:
// 擦除之前
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;
}
}
// 泛型接口
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");
}
}
public void test(Object object);
subGeneric.test(1);
程序可以编译成功,但是会报ClassCastException:java.lang.Integer cannot be case to java.long.String。
目前为止,这里面有两个问题:
编译器会帮我们生成一个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