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