Type

Type在反射中应用较多，主要用于获取类型。比如：是否是泛型，是否是变量类型等等。

通过它的子类获取更多信息。它的子类有五个：Class、GenericArrayType、ParameterizedType、TypeVariable、WildcardType。

其中只有Class是实体类，其它都是接口类，且本章主要讲述接口类。

ParameterizedType

ParameterizedType是参数化类型，即带有泛型的类型，比如List<String>、Set<Long>、Map<String, Long>、Class<Float>等类型。

其中它有三个方法，Teyp[] getActualTypeArguments()、Type getRawType()、Type getOwnerType()。

getActualTypeArguments()

该方法是获取该类型中的泛型类型，比如List<String>类型中获取到的就是String类型，因为可以有多个泛型，比如Map<String, Long>，所以是返回Type[]。
```
public class TypeTest {
    List<String> ptFiled;
}
```
定义一个TypeTest类，有一个带泛型的成员变量ptFiled。
```
Field field = TypeTest.class.getDeclaredField("ptFiled");
Type type = field.getGenericType();
if (type instanceof ParameterizedType) {
    Log.e(TAG, "type is ParameterizedType");
    Type[] typeArguments = ((ParameterizedType) type).getActualTypeArguments();
    Log.e(TAG, "type = " + type);
    for (Type item : typeArguments) {
        Log.e(TAG, "actualTypeArgument = " + item);
    }
}
```
通过反射获取该变量的类型，判断是否是ParameterizedType，然后调用getActualTypeArguments()方法获取泛型类型数组，打印泛型类型。

打印结果

getActualTypeArguments.png

通过getActualTypeArguments()可以知道泛型的类型是String，如果是Map<String, Long>的话，得到的就是String和Long类型。

getRawType()

该方法是获取对应的原始类型，以上面代码为例，变量ptFiled是List<String>类型，那么ptFiled的原始类型就是List。
```
if (type instanceof ParameterizedType) {
    Log.e(TAG, "rawType = " + ((ParameterizedType) type).getRawType());
}
```
打印结果

getRawType.png

getOwnerType()

该方法是获取拥有者的类型，说简单点就是当该类型是内部类的时候，获取外层类的类型，不是内部类获取返回的都是null。
```
public class TypeTest<T extends List & Collection> {
    TypeTestInner<String> ptFiled;
      List<T> listPtFiled;

    static class TypeTestInner<F> {
        List<Integer> list;
    }
}
```
以上两个属性都是ParameterizedType类型，当listPtFiled调用getOwnerType()获取到的是null，而ptFiled调用getOwnerType()获取到的是TypeTest类型。
```
if (type instanceof ParameterizedType) {
    Log.e(TAG, "type is ParameterizedType");
    Log.e(TAG, "ownerType = " + ((ParameterizedType) type).getOwnerType());
}
```
listPtFiled调用的打印结果：

getOwnerType1.png

ptFiled调用的打印结果：

getOwnerType2.png

TypeVariable

TypeVariable是泛型类型，比如常见的T t和List<E>中的E。

该接口也是有三个方法，Type[] getBounds()、D getGenericDeclaration()、String getName()。

getBounds()

该方法是获取边界数组，比如TypeTest<T extends List>中的T的上边界是List，如果没有上边界，那么上边界就是Object。
因为是获取数组，所以有这么一种形式TypeTest<T extends List & Collction>，这里面返回的Type[]是[List, Collection]，看代码直观一点。
```
public class TypeTest<T extends List & Collection> {
    List<T> ptFiled;
    T tvFiled;
}
```
下面来看看调用和打印，也是用反射获取字段tvFiled。
```
if (type instanceof TypeVariable) {
    Log.e(TAG, "type is TypeVariable");
    Type[] bounds = ((TypeVariable) type).getBounds();
    Log.e(TAG, "type = " + type);
    for (Type item : bounds) {
        Log.e(TAG, "bounds = " + item);
    }
}
```
打印结果：

getBounds1.png

其中List<T> ptFiled属于ParameterizedType，不过里面的T是TypeVariable，可以这样来获取：

Field field = TypeTest.class.getDeclaredField("ptFiled");
Type type = field.getGenericType();
if (type instanceof ParameterizedType) {
    Log.e(TAG, "type is ParameterizedType");
    Type[] typeArguments = ((ParameterizedType) type).getActualTypeArguments();
    Log.e(TAG, "type = " + type);
    for (Type item : typeArguments) {
        Log.e(TAG, "actualTypeArgument = " + item);
        if (item instanceof TypeVariable) {
            Log.e(TAG, "item is TypeVariable");
            Type[] itemTypes = ((TypeVariable) item).getBounds();
            Log.e(TAG, "item = " + item);
            for (Type itemType : itemTypes) {
                Log.e(TAG, "bounds = " + itemType);
            }
        }
    }
    Log.e(TAG, "rawType = " + ((ParameterizedType) type).getRawType());
}

打印结果：

getBounds2.png

getGenericDeclaration()

该方法是获取类属，即获取属于哪个类的，如上面的T tvFiled是属于TypeTest的，所以返回的是TypeTest类型。
```
Log.e(TAG, "getGenericDeclaration = " + ((TypeVariable) type).getGenericDeclaration());
```
打印结果：

getGenericDeclaration.png

getName()

该方法是获取泛型名字，即T t就是获取到T。
```
Log.e(TAG, "getName = " + ((TypeVariable) type).getName());
```
打印结果：

getName.png

GenericArrayType

GenericArrayType是泛型数组类型。这个理解起来其实比较简单，两个前提组成，一是泛型，二是数组，即带泛型的数组类型。

比如T[] t、List<T>[] list等，有泛型且有数组的类型。

其中它有一个方法，Type getGenericComponentType()。

getGenericComponentType()

该方法是获取数组的类型，即返回的Type是数组的类型，比如T[] t，返回的就是T，List<T> list返回的就是List<T>。
```
public class TypeTest<T extends List & Collection> {
    List<T> ptFiled;
    T tvFiled;
    T[] gatFiled;
}
```
这里获取gatFiled字段的类型，还是用上述反射来获取。
```
if (type instanceof GenericArrayType) {
    Log.e(TAG, "getGenericComponentType = " + ((GenericArrayType) type).getGenericComponentType());
}
```
打印结果：

getGenericComponentType.png

这种情况是否有点熟悉？是的，这个T类型就是TypeVariable，从而可以获取到这个泛型的信息。如果是List<T>[] list这种情况获取到的就是List<T>，也就是ParameterizedType类型，

WildcardType

WildcardType是通配符类型，通配符是?，也就是当该类型是ParameterizedType时，当里面的泛型是通配符？时，该泛型就是WildcardType。

该接口有两个方法，Type[] getUpperBounds()、Type[] getLowerBounds()。

getUpperBounds()

该方法是获取上边界数组，也就是List<? Extends Map>取到的上边界是Map。

getLowerBounds()

该方法是获取下边界数组，即List<? super Set>取到的下边界是Set。

public class TypeTest<T extends List & Collection> {
    List<T> ptFiled;
    T tvFiled;
    T[] gatFiled;
    List<? extends Map> upperWtFiled;
    List<? super Set> lowerWtFiled;
    List<?> wfFiled;
}

这里尝试获取lowerWtFiled字段。

for (Field field : TypeTest.class.getDeclaredFields()) {
    Type type = field.getGenericType();
    if (type instanceof ParameterizedType) {
        Log.e(TAG, field.getName() + " is ParameterizedType");
        Type[] typeArguments = ((ParameterizedType) type).getActualTypeArguments();
        for (Type item : typeArguments) {
            if (item instanceof WildcardType) {
                Log.e(TAG, field.getName() + " item is WildcardType");
                Log.e(TAG, "upper = " + Arrays.toString(((WildcardType) item).getUpperBounds()));
                Log.e(TAG, "lower = " + Arrays.toString(((WildcardType) item).getLowerBounds()));
            }
        }
    }
}

打印结果：

getUpperBounds&&getLowerBounds.png

这里lowerWtFiled和wfFiled没有设置上边界，默认是Object，而lowerWtFiled下边界则是Set。

结尾

Type系列接口就这四个，方法也不多，但是却很有用，大部分是围绕着泛型来获取信息。

这里举个比较有用的例子：比如Retrofit里面的两个Factory类也是依靠Type来进行数据的转化和返回定义的格式，而且还能通过注解配合使用。

Type到这里就告一段落了，下一篇文章来说说Retrofit的两个Factory类吧。

Type的几个接口子类讲解