基础篇：深刻解析JAVA泛型
1 JAVA的Type类型体系
- 先了解下java的Type类型体系(类的类=>类型)，Type是全部类型（原生类型-Class、参数化类型-Parameterizedtype、数组类型-GenericArrayType、类型变量-TypeVariable、基本类型-Class）的共同接口;前两篇反射和注解讲到的Class<T>就是Type的一实现类
Type下面又有四个子接口类ParameterizedType、TypeVariable、GenericArrayType、WildcardTypejava
- List<E>表示泛型，E是TypeVariable类型，List<String>则是ParameterizedType(参数化类型)，List<String>里的String称为实际参数类型
- 具体化泛型中的类型时，可使用 ? extends 或 ? super来表示继承关系；如
List<? extends Data>，而里面的 ? 称为通配符类型WildcardType - GenericArrayType 表示一种元素类型是ParameterizedType（参数化类型）或者TypeVariable（类型变量）的数组类型，如T[] 或者 List<E>[]
- 注解是JDK1.5才出现了的，为了表示被注解的类型的，加入AnnotatedElement类型，字面意思就是被注解的元素。JDK1.8又有了AnnotatedType将Type和被注解元素的概念关联起来。
- AnnotatedType也有四个子接口，和Type的四个子接口一一对应，如：ParameterizedType类型被注解则被编译器解析成AnnotatedParameterizedType:
@AnTest("list")List<String>list
2 泛型的概念
- Java 泛型（generics）是JDK1.5中引入的一个新特性，其本质是参数化类型，解决不肯定具体对象类型的问题;其所操做的数据类型被指定为一个参数（type parameter）这种参数类型能够用在类、接口和方法的建立中，分别称为泛型类、泛型接口、泛型方法
泛型: 把类型明确的工做推迟到建立对象或调用方法的时候才去明确的特殊的类型
3 泛型类和泛型方法的示例
- 泛型类的定义
public class MainTest<T> {
private T param;
}
public static void main(String[] args){
MainTest<String> data = new MainTest<String>(){};
ParameterizedType genType1 = (ParameterizedType)data.getClass().getGenericSuperclass();
}
- 泛型方法的定义
public class MainTest{
public static void main(String[] args){
printData("siting");
}
static <T> T printData(T t){
System.out.println(t);
return t;
}
}
- 接口和抽象类均可以使用泛型
4 类型擦除
- 建立泛型的实例时，jvm是会把具体类型擦除的；编译生成的字节码中不包含泛型中的类型参数，即ArrayList<String>和ArrayList<Integer>都擦除成了ArrayList，也就是被擦除成"原生类型"，这就是泛型擦除
public class MainTest {
public static void main(String[] args){
List<String> strArr = new ArrayList<>();
List<Integer> intArr = new ArrayList<>();
Type strClazz = strArr.getClass();
Type intClazz = intArr.getClass();
}
}
- 查看编译后的字节码文件是如何表示的: idea菜单 -> view -> show ByteCode
public class MainTest<T> {
T param;
public static void main(String[] args){
MainTest<String> test = new MainTest<>();
test.setParam("siting");
}
public T getParam() { return param; }
public void setParam(T param) { this.param = param; }
}
public class com/MainTest {
...省略
public static main([Ljava/lang/String;)V
L0
LINENUMBER 7 L0
NEW com/MainTest
DUP
INVOKESPECIAL com/MainTest.<init> ()V
ASTORE 1
L1
LINENUMBER 8 L1
ALOAD 1
LDC "siting" // 调用类型擦除后的setParam(Object)
INVOKEVIRTUAL com/MainTest.setParam (Ljava/lang/Object;)V
L2
...省略//getParam 的返回值是Object
public getParam()Ljava/lang/Object;
L0
LINENUMBER 10 L0
ALOAD 0
GETFIELD com/MainTest.param : Ljava/lang/Object;
ARETURN
...省略//setParam 的入参是Object
public setParam(Ljava/lang/Object;)V
L0
LINENUMBER 11 L0
ALOAD 0
ALOAD 1
PUTFIELD com/MainTest.param : Ljava/lang/Object;
RETURN
...
}
- 能够看出T(String)都被转换为Object类型，最初的初始化的String不见了
5 泛型的继承
- 子类能够指定父类的泛型参数，能够是已知类（Integer、String等），也能够用子类本身的泛型参数指定
- 泛型被继承时，且指定父类泛型参数，则额外生成的ParameterizedType类型做为子类的父类；若是没有指定父类泛型参数，则直接继承原生类型
public class MainTest<T> {
T param;
static public class SubTest1 extends MainTest<String>{}
static public class SubTest2<R> extends MainTest<R>{}
//SubTest3继承的时原生类型
static public class SubTest3 extends MainTest{}
}
6 泛型变量TypeVariable
- （先临时定义一个名称，Test<E>里的E为泛型参数）；泛型变量TypeVariable：泛型的泛型参数就是TypeVariable；当父类使用子类的泛型参数指定自身的泛型参数时；或者泛型属性定义在泛型类A<T>中，并使用泛型类A<T>的泛型参数T时，其泛型参数都会被编译器定为泛型变量TypeVariable，而不是被擦除
public class MainTest<T> {
List<T> param;
public static void main(String[] args) throws Exception{
Class clazz = MainTest.class;
TypeVariable[] typeVariable = clazz.getTypeParameters();
// 1
Field field = clazz.getDeclaredField("param");
ParameterizedType arrayType = (ParameterizedType)field.getGenericType();
// interface List<E> 的泛型类型E被T,具体化，所以其被识别为 TypeVariable
TypeVariable variable1 = (TypeVariable)arrayType.getActualTypeArguments()[0];
// 2
ParameterizedType type = (ParameterizedType)SubTest.class.getGenericSuperclass();
TypeVariable variable2 = (TypeVariable)type.getActualTypeArguments()[0];
}
static class SubTest<R> extends MainTest<R>{}
}
7 参数化类型ParameterizedType
public interface ParameterizedType extends Type {
//获取实际参数，List<String>里的String; 若是是List<T>则是TypeVariable类型
Type[] getActualTypeArguments();
// 获取原始类型List<String> -> List<E>
Type getRawType();
Type getOwnerType();
}
- 须要注意的点，咱们不能直接获取指定具体参数的泛型的类型，如
Class clazz = List<String>.class编译时不经过的；还有就是直接经过泛型类new建立的对象，其Class并不是ParameterizedType类型，而是泛型自己的class，示例以下
public class MainTest<T> {
public static void main(String[] args){
MainTest<String> str = new MainTest<String>();
Class variable = str.getClass();
Type genType1 = variable.getGenericSuperclass();
}
}
- 被具体参数化的泛型才能被编译器识别为ParameterizedType类型，有三种方式获取ParameterizedType类型
// 1 子类继承泛型时，指定具体参数（能够是String等已知类型,也能够是子类的泛型参数）
// 2 获取在类内部定义的泛型属性，需指定具体泛型参数
// 3 局部代码，能够经过泛型的匿名内部子类(需指定具体泛型参数)获取ParameterizedType类型
public class MainTest<T> {
List<T> list;
public static void main(String[] args) throws NoSuchFieldException {
SubTest<String> str = new SubTest<>();
// 方式一
Class variable = str.getClass();
// 父类是(521)ParameterizedType类型
ParameterizedType genType = (ParameterizedType)variable.getGenericSuperclass();
// (521)ParameterizedType类型的原生类型是（479）class com.MainTest
Type clazz = genType.getRawType();
//MainTest.class 的原生类型是 （479）class com.MainTest
Class rawClazz = MainTest.class;
//方式二，泛型属性
Field field = rawClazz.getDeclaredField("list");
//属性list 类型是(546)ParameterizedType类型List<T>
ParameterizedType fieldType = (ParameterizedType)field.getGenericType();
// 方式三
MainTest<String> sub3 = new MainTest<String>(){};
// clazz3是匿名子类
Class clazz3 = sub3.getClass();
//父类是(555)ParameterizedType类型
ParameterizedType genType3 = (ParameterizedType) clazz3.getGenericSuperclass();
// (555)ParameterizedType类型的原生类型是（479）class com.MainTest
Type type3 = genType3.getRawType();
}
public static class SubTest<R> extends MainTest<R>{ }
}
8 通配符(WildcardType)
无边界通配符：无界通配符 ? 能够适配任何引用类型:
- 当方法参数须要传入一个泛型时，并且没法肯定其类型时。直接使用无具体泛型变量的泛型，容易形成安全隐患；若在方法代码里进行类型转换，极容易出现ClassCastException错误
- 那泛型变量用Object代替不就好了？可是泛型类+具体参数转变的ParameterizedType(参数化类型)是不存在继承关系；即Object是String的父类，可是List<Object>和List<String>的类型是不一样的两个ParameterizedType，不存在继承关系。因而有了类型通配符 ？
public static void print(List list){}
----->>>
public static void print(List<?> list){}
- 无界通配符能够匹配任意类型；可是在使用？时，不能给泛型类的变量设置值，由于咱们不知道具体类型是什么；若是强行设置新值，后面的读容易出现ClassCastException错误。所以编译器限制了通配符 ？的泛型只能读不能写
上界限定通配符 < ? extends E>
- 想接收一个List集合，它只能操做数字类型的元素【Float、Integer、Double、Byte等数字类型都行】，怎么作？可使用
List<? extends Number的子类>，代表List里的元素都是Number的子类
public static void print(List<? extends Number> list) {
Number n = new Double("1.0");
list.add(n);
Number tmp = list.get(0);
}
- 图片里能够看出，存在上界通配符，由于具体类型不肯定，也是只能读不能写的
下界限定通配符 < ? super E>
class Parent{ }
class Child extends Parent{ }
public class MainTest<T> {
T param;
public static void main(String[] args){
MainTest<? super Child> parent_m = new MainTest<>();
parent_m.setParam(new Child());
Object parent = parent_m.getParam();
}
public T getParam() { return param; }
public void setParam(T param) { this.param = param; }
}
- 若是定义了通配符是谁的父类，则是下界限定通配符；此类通配符可读可写，转成任意父类都不会出现ClassCastException错误。
- 我的猜测：难道是由于通配符和上界限定通配符的泛型 向下转型容易出现ClassCastException错误，而下界限定通配符向上转型不会出现ClassCastException错误，所以java规范限制前者编译出错，然后面编译经过？
9 泛型数组(GenericArrayType)
public interface GenericArrayType extends Type {
//得到这个数组元素类型，即得到：A<T>（A<T>[]）或 T（T[]）
Type getGenericComponentType();
}
- GenericArrayType，泛型数组，描述的是ParameterizedType类型以及TypeVariable类型数组，即形如：Test<T>[][]、T[]等，是GenericArrayType的子接口
public class MainTest<T> {
T[] param;
public static void main(String[] args) throws Exception{
Class clazz = MainTest.class;
Field field = clazz.getDeclaredField("param");
GenericArrayType arrayType = (GenericArrayType)field.getGenericType();
TypeVariable variable = (TypeVariable) arrayType.getGenericComponentType();
}
}
欢迎指正文中错误
关注公众号，一块儿交流
相关文章
- 1. 基础篇：深刻解析JAVA泛型
- 2. Java泛型深刻解析
- 3. 基础篇：深刻解析JAVA异常
- 4. java泛型深刻理解
- 5. 深刻理解Java泛型
- 6. 深刻理解 Java 泛型
- 7. Java泛型深刻理解
- 8. Java基础--泛型篇
- 9. 深刻理解Java泛型：你对泛型的理解够深刻吗？
- 10. Java泛型深刻题目
- 更多相关文章...
- • C# 泛型（Generic） - C#教程
- • Swift 泛型 - Swift 教程
- • Kotlin学习（二）基本类型
- • ☆基于Java Instrument的Agent实现
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
欢迎关注本站公众号,获取更多信息
相关文章
- 1. 基础篇：深刻解析JAVA泛型
- 2. Java泛型深刻解析
- 3. 基础篇：深刻解析JAVA异常
- 4. java泛型深刻理解
- 5. 深刻理解Java泛型
- 6. 深刻理解 Java 泛型
- 7. Java泛型深刻理解
- 8. Java基础--泛型篇
- 9. 深刻理解Java泛型：你对泛型的理解够深刻吗？
- 10. Java泛型深刻题目