java Type 详解

骑猪看日落 2022-06-18 07:18 171阅读 0赞

**为什么要写这一系列的博客呢？**

因为在 Android 开发的过程中， 泛型，反射，注解这些知识进场会用到，几乎所有的框架至少都会用到上面的一两种知识，如 Gson 就用到泛型，反射，注解，Retrofit 也用到泛型，反射，注解 。

**学好这些知识对我们非常重要，就像打地基一样，万丈高楼平地起。对我们阅读开源框架会有很大的帮助**。

[java Type 详解][java Type]

[java 反射机制详解][java]

[注解使用入门（一）][Link 1]

[Android 自定义编译时注解1 - 简单的例子][Android _1 -]

[Android 编译时注解 —— 语法详解][Android _ _]

[带你读懂 ButterKnife 的源码][ButterKnife]

感兴趣的可以关注我哦，**希望我们可以成为朋友，成长路上的忠实伙伴！**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dkdXR4aWFveHU_size_16_color_FFFFFF_t_70]

## **前言** ##

错误可分为两种：**编译时错误与运行时错误**。编译时错误在编译时可以发现并排除，而运行时错误具有很大的不确定性，在程序运行时才能发现，造成的后果可能是灾难性的。

泛型的引入使得一部分错误可以提前到编译时期发现，极大地增强了代码的健壮性。但是我们知道 java 泛型在运行的时候是会进行泛型擦除的，那我们要怎样得到在编译时期泛型的信息呢？

java 为我们提供了 Type 接口，使用它，我们可以得到这些信息。

不知道什么是泛型擦除的同学可以看一下

**类型擦除是指泛型在运行的时候会去除泛型的类型信息**。java 中，泛型主要是在编译层次来实现的，在生成的字节码即 class 文件是不包括泛型的 类型信息的。

即 List <String>， List<Object> ，List<Integer> 虽然在编译时候是不同的，但是在编译完成后，在class 文件 中都只会把他们当作 List 来对待。

--------------------

## **Type 接口简介** ##

### 类 UML 图如下 ###

![33f4f9809a28422c4b691001f4cd9732.png][]

简单来说：Type是所有类型的父接口, 如原始类型(raw types 对应 Class)、 参数化类型(parameterized types 对应 ParameterizedType)、 数组类型(array types 对应 GenericArrayType)、 类型变量(type variables 对应 TypeVariable )和基本(原生)类型(primitive types 对应 Class),。

子接口有 ParameterizedType, TypeVariable, GenericArrayType, WildcardType, 实现类有Class。

--------------------

## **ParameterizedType （参数化类型）** ##

官方文档的说明是这样的

> ParameterizedType represents a parameterized type such as  
> Collection<String>

**需要注意的是，并不只是 Collection<String> 才是 parameterized，任何类似于 ClassName 这样的类型都是 ParameterizedType ，比如下面的这些都是 parameterizedType.**

Map<String, Person> map;
    	Set<String> set1;
    	Class<?> clz;
    	Holder<String> holder;
    	List<String> list;
    
    	static class Holder<V>{
    		
    	}

而类似于这样的 ClassName 不是 ParameterizedType.

Set set;
    List aList;

### ParameterizedType 的几个主要方法 ###

*  Type\[\] getActualTypeArguments();
 *  Type getRawType();
 *  Type getOwnerType();

Type\[\] getActualTypeArguments(); 返回 这个 Type 类型的参数的实际类型数组。 如 Map<String,Person> map 这个 ParameterizedType 返回的是 String 类,Person 类的全限定类名的 Type Array。

Type getRawType() 返回的是当前这个 ParameterizedType 的类型。 如 Map<String,Person> map 这个 ParameterizedType 返回的是 Map 类的全限定类名的 Type Array。

Type getOwnerType();

> Returns a \{@code Type\} object representing the type that this type is a member of.

这个比较少用到。返回的是这个 ParameterizedType 所在的类的 Type （注意当前的 ParameterizedType 必须属于所在类的 member）。解释起来有点别扭，还是直接用代码说明吧。 **比如 Map<String,Person> map 这个 ParameterizedType 的 getOwnerType() 为 null，而 Map.Entry<String, String>entry 的 getOwnerType() 为 Map 所属于的 Type。**

说了这么多，下面我们一起来看一下例子，加深印象。

public class ParameterizedTypeBean {
    	// 下面的 field 的 Type 属于 ParameterizedType
    	Map<String, Person> map;
    	Set<String> set1;
    	Class<?> clz;
    	Holder<String> holder;
    	List<String> list;
    	// Map<String,Person> map 这个 ParameterizedType 的 getOwnerType() 为 null，
    	// 而 Map.Entry<String, String> entry 的 getOwnerType() 为 Map 所属于的 Type。
    	Map.Entry<String, String> entry;
    	// 下面的 field 的 Type 不属于ParameterizedType
    	String str;
    	Integer i;
    	Set set;
    	List aList;
    
    	static class Holder<V> {
    
    	}
    }

public class TestHelper {
    
    	public static void testParameterizedType() {
    		Field f = null;
    		try {
    			Field[] fields = ParameterizedTypeBean.class.getDeclaredFields();
                // 打印出所有的 Field 的 TYpe 是否属于 ParameterizedType
    			for (int i = 0; i < fields.length; i++) {
    				f = fields[i];
    				PrintUtils.print(f.getName()
    						+ " getGenericType() instanceof ParameterizedType "
    						+ (f.getGenericType() instanceof ParameterizedType));
    			}
    			getParameterizedTypeMes("map" );
    			getParameterizedTypeMes("entry" );
    			
    
    		} catch (NoSuchFieldException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (SecurityException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    
    	}
    
    	private static void getParameterizedTypeMes(String fieldName) throws NoSuchFieldException {
    		Field f;
    		f = ParameterizedTypeBean.class.getDeclaredField(fieldName);
    		f.setAccessible(true);
    		PrintUtils.print(f.getGenericType());
    		boolean b=f.getGenericType() instanceof ParameterizedType;
    		PrintUtils.print(b);
    		if(b){
    			ParameterizedType pType = (ParameterizedType) f.getGenericType();
    			PrintUtils.print(pType.getRawType());
    			for (Type type : pType.getActualTypeArguments()) {
    				PrintUtils.print(type);
    			}
    			PrintUtils.print(pType.getOwnerType()); // null
    		}
    	}
    }

> print:map getGenericType() instanceof ParameterizedType true
> 
> print:set1 getGenericType() instanceof ParameterizedType true
> 
> print:clz getGenericType() instanceof ParameterizedType true
> 
> print:holder getGenericType() instanceof ParameterizedType true
> 
> print:list getGenericType() instanceof ParameterizedType true
> 
> print:str getGenericType() instanceof ParameterizedType false
> 
> print:i getGenericType() instanceof ParameterizedType false
> 
> print:set getGenericType() instanceof ParameterizedType false
> 
> print:aList getGenericType() instanceof ParameterizedType false
> 
> print:entry getGenericType() instanceof ParameterizedType true
> 
> print:java.util.Map<java.lang.String, com.xujun.gennericity.Person>
> 
> print:true
> 
> print:interface java.util.Map
> 
> print:class java.lang.String
> 
> print:class com.xujun.gennericity.Person
> 
> print:null
> 
> print:java.util.Map.java.util.Map$Entry<java.lang.String, java.lang.String>
> 
> print:true
> 
> print:interface java.util.Map$Entry
> 
> print:class java.lang.String
> 
> print:class java.lang.String
> 
> print:interface java.util.Map

--------------------

## **TypeVariable 变量** ##

比如 public class TypeVariableBean<K extends InputStream & Serializable, V> ，K ，V 都是属于类型变量。

### 主要方法 ###

*  Type\[\] getBounds(); 得到上边界的 Type数组，如 K 的上边界数组是 InputStream 和 Serializable。 V 没有指定的话，上边界是 Object
 *  D getGenericDeclaration(); 返回的是声明这个 Type 所在的类 的 Type
 *  String getName(); 返回的是这个 type variable 的名称

public class TypeVariableBean<K extends InputStream & Closeable, V> {
    	// K 的上边界是 InputStream
    	K key;
    	// 没有指定的话 ，V 的 上边界 属于 Object
    	V value;
    	// 不属于 TypeTypeVariable
    	V[] values;
    	String str;
    	List<K> kList;
    
    }

TypeVariableBean bean = new TypeVariableBean<FileInputStream, String>();
    fk = TypeVariableBean.class.getDeclaredField("key");
    eyType = (TypeVariable) fk.getGenericType();
    System.out.println(keyType.getName());System.out.println(keyType.getGenericDeclaration());

执行上述代码，将可以看到如下的效果

> K
> 
> class com.xujun.gennericity.beans.TypeVariableBean

--------------------

## **GenericArrayType** ##

> represents an array type whose component  
> type is either a parameterized type or a type variable.

简单来说就是：范型数组,组成数组的元素中有范型则实现了该接口; 它的组成元素是 ParameterizedType 或 TypeVariable 类型

// 属于 GenericArrayType
    List<String>[] pTypeArray;
    // 属于 GenericArrayType
    T[] vTypeArray;
    // 不属于 GenericArrayType
    List<String> list;
    // 不属于 GenericArrayType
    String[] strings;
    // 不属于 GenericArrayType
    Person[] ints;

下面我们一起来看一下例子

public class GenericArrayTypeBean<T> {
    	
    	public void test(List<String>[] pTypeArray, T[] vTypeArray,
    			 List<String> list, String[] strings, Person[] ints) {
    	    }
    }

public static void testGenericArrayType() {
    		Method method = GenericArrayTypeBean.class.getDeclaredMethods()[0];
    		System.out.println(method);
    		// public void test(List<String>[] pTypeArray, T[]
    		// vTypeArray,List<String> list, String[] strings, Person[] ints)
    		Type[] types = method.getGenericParameterTypes(); // 这是 Method 中的方法
    		for (Type type : types) {
    			System.out.println(type instanceof GenericArrayType);// 依次输出true，true，false，false，false
    		}
    	}

输出结果

> public void com.xujun.gennericity.beans.GenericArrayTypeBean.test(java.util.List\[\],java.lang.Object\[\],java.util.List,java.lang.String\[\],com.xujun.gennericity.Person\[\])
> 
> true
> 
> true
> 
> false
> 
> false
> 
> false

--------------------

## WildcardType 通配符的类型 ##

> \{@code ?\}, \{@code ? extends Number\}, or \{@code ? super Integer\} 这些类型 都属于 WildcardType

**extends 用来指定上边界，没有指定的话上边界默认是 Object， super 用来指定下边界，没有指定的话为 null。**

几个主要方法介绍

*  Type\[\] getLowerBounds() 得到上边界 Type 的数组
 *  Type\[\] getUpperBounds() 得到下边界 Type 的数组

下面一起来看一下例子。

public class WildcardTypeBean {
    	private List<? extends Number> a;  // a没有下界,
    //	没有指定的话，上边界默认是 Object ,下边界是 	String						
    	private List<? super String> b; 
    	
    	private List<String> c;
    	
    	private Class<?> aClass;
    }

public static void testWildCardType() {
    		try {
    			Field[] fields = WildcardTypeBean.class.getDeclaredFields();
    			for (int i = 0; i < fields.length; i++) {
    				Field field = fields[i];
    				Type type = field.getGenericType();
    				String nameString = field.getName();
    				PrintUtils.print("下面开始打印" + nameString + "是否具有通配符");
    				if (!(type instanceof ParameterizedType)) {
    					PrintUtils.print("---------------------------");
    					continue;
    				}
    				ParameterizedType parameterizedType = (ParameterizedType) type;
    				type = parameterizedType.getActualTypeArguments()[0];
    				if (!(type instanceof WildcardType)) {
    					PrintUtils.print("---------------------------");
    					continue;
    				}
    				WildcardType wildcardType = (WildcardType) type;
    				Type[] lowerTypes = wildcardType.getLowerBounds();
    				if (lowerTypes != null) {
    					PrintUtils.print("下边界");
    					PrintUtils.printTypeArr(lowerTypes);
    				}
    				Type[] upTypes = wildcardType.getUpperBounds();
    				if (upTypes != null) {
    					PrintUtils.print("上边界");
    					PrintUtils.printTypeArr(upTypes);
    				}
    				PrintUtils.print("---------------------------");
    
    			}
    			Field fieldA = WildcardTypeBean.class.getDeclaredField("a");
    			Field fieldB = WildcardTypeBean.class.getDeclaredField("b");
    			// 先拿到范型类型
    			PrintUtils.print(fieldA.getGenericType() instanceof ParameterizedType);
    			PrintUtils.print(fieldB.getGenericType() instanceof ParameterizedType);
    			ParameterizedType pTypeA = (ParameterizedType) fieldA.getGenericType();
    			ParameterizedType pTypeB = (ParameterizedType) fieldB.getGenericType();
    			// 再从范型里拿到通配符类型
    			PrintUtils.print(pTypeA.getActualTypeArguments()[0] instanceof WildcardType);
    			PrintUtils.print(pTypeB.getActualTypeArguments()[0] instanceof WildcardType);
    			WildcardType wTypeA = (WildcardType) pTypeA.getActualTypeArguments()[0];
    			WildcardType wTypeB = (WildcardType) pTypeB.getActualTypeArguments()[0];
    			// 方法测试
    			System.out.println(wTypeA.getUpperBounds()[0]); 
    			System.out.println(wTypeB.getLowerBounds()[0]); 
    			// 看看通配符类型到底是什么, 打印结果为: ? extends java.lang.Number
    			System.out.println(wTypeA);
    		} catch (NoSuchFieldException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (SecurityException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    
    	}

## **java Type 总结** ##

Type及其子接口的来历

*  泛型出现之前的类型

没有泛型的时候，只有原始类型。此时，所有的原始类型都通过字节码文件类Class类进行抽象。Class类的一个具体对象就代表一个指定的原始类型。

*  泛型出现之后的类型

泛型出现之后，扩充了数据类型。从只有原始类型扩充了参数化类型、类型变量类型、限定符类型 、泛型数组类型。

### 为什么会产生泛型擦除的原因 ###

我们知道在 jdk 1.5 以前的时候，是没有 泛型的。在 jdk 1.5 的时候，才引入了泛型。如果真的在动态运行的时候加入泛型，涉及到 JVM 命令的修改，这无疑是非常致命的。因此折中采取了这样的策略，在编译的时候进行检查，在运行的时候进行擦除，也是我们说的泛型擦除。 同时这也说明一点，在设计框架的时候，框架的健壮性和灵活性非常重要。

### 为什么要学习 Type ###

我们知道现在的框架都会使用泛型，掌握 Type 有利于我们读懂它们的源码，或者自己动手打造框架。如 Android 的常用开源框架 Gson ，Retrofit等。

## **题外话** ##

最近更新博客的频率有点低，主要是因为惰性吧。每天实习完以后，有点累，就不太想写博客了。我现在也不知道我能坚持到什么时候，顺其自然吧。**PS，真的越来越佩服那些坚持写博客的人，你们是最棒的。**

[文章首发地址　CSDN][java Type]

[Demo下载地址][Demo]

## 找到我 ##

我是站在巨人的肩膀上成长起来的，同样，我也希望成为你们的巨人。觉得不错的话可以关注一下我的微信公众号程序员徐公，在此感谢各位大佬们。主要分享

1.**Android 开发相关知识**：包括 java，kotlin， Android 技术。  
2.**面试相关分享**：包括常见的面试题目，大厂面试真题、面试经验套路分享。  
3.**算法相关学习笔记**：比如怎么学习算法，leetcode 常见算法总结，跟大家一起学习算法。  
4.**时事点评**：主要是关于互联网的，比如小米高管屌丝事件，拼多多女员工猝死事件等

希望我们可以成为朋友，成长路上的忠实伙伴！

![32330cdfb6f0dfc77e5e0eccfc2d7dde.png][]

[java Type]: http://blog.csdn.net/gdutxiaoxu/article/details/68926515
[java]: http://blog.csdn.net/gdutxiaoxu/article/details/68947735
[Link 1]: http://blog.csdn.net/gdutxiaoxu/article/details/52017033
[Android _1 -]: http://blog.csdn.net/gdutxiaoxu/article/details/70244169
[Android _ _]: http://blog.csdn.net/gdutxiaoxu/article/details/70822023
[ButterKnife]: http://blog.csdn.net/gdutxiaoxu/article/details/71512754
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dkdXR4aWFveHU_size_16_color_FFFFFF_t_70]: /images/20220618/e963dd3a20074df8908827a5df9aad64.png
[33f4f9809a28422c4b691001f4cd9732.png]: /images/20220618/2fea40ffee6340729f6d829415f7de0f.png
[Demo]: http://download.csdn.net/detail/gdutxiaoxu/9800329
[32330cdfb6f0dfc77e5e0eccfc2d7dde.png]: /images/20220618/d1948e013a2e49f885678cbf4ab6e577.png