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类吧。