Java 泛型之type

2018-08-31 本文已影响22人 PuHJ

一、泛型的好处

简单的说，

泛型编程，意味着编写的代码可以被很多不同类型的对象所重用。比如ArrayList类使用泛型可以聚合Integer和String，而不是单独编写个ArrayList。有种多态的感觉。
提供错误检查机制，如ArrayList<String> list = new ArrayList<>();list就不可以添加非String类型的变量，java编译器就会错误检测。再者不需要提供强制类型装换，如String s = list.get(0);

二、类型变量命名约定

T ：普通的泛型
K ： Key的简写，用于键值对的键
V ： Value的简写，用于键值对的值

三、泛型体系

Type体系

（1）、Type接口

官方的解释：Type 是 Java 编程语言中所有类型的公共高级接口。它们包括原始类型、参数化类型、数组类型、类型变量和基本类型。

/**
 * Type is the common superinterface for all types in the Java
 * programming language. These include raw types, parameterized types,
 * array types, type variables and primitive types.
 *
 * @since 1.5
 */
public interface Type {
    /**
     * Returns a string describing this type, including information
     * about any type parameters.
     *
     * @implSpec The default implementation calls {@code toString}.
     *
     * @return a string describing this type
     * @since 1.8
     */
    default String getTypeName() {
        return toString();
    }
}

从图中可以看出Type的四大子接口，它们分别代表不同的类型：

原始类型(Class) ：对应的就是普通的类，注解等。如String.getClass()就是一个原始类型。
参数化类型(ParameterizedTypes)：是整个泛型，如List<T> list;
类型变量(TypeVariable) ：如List<T> list 中的T
数组类型(GenericArrayType) ：并不是普通的数组String[] 、byte[]，而是带有泛型的数组，即T[]
基本类型：基本类型，即int,float,double等。
通配符类型（WildcardType）：List<?> 带有？的

泛型多是在框架中应用比较多，如Retrofit框架中的源码，该方法的大体意思就像是获取List<String>中的最外层的List类型。

  static Class<?> getRawType(Type type) {
    if (type == null) throw new NullPointerException("type == null");

    if (type instanceof Class<?>) {
      // Type is a normal class.
      return (Class<?>) type;
    }
    if (type instanceof ParameterizedType) {
      ParameterizedType parameterizedType = (ParameterizedType) type;

      // I'm not exactly sure why getRawType() returns Type instead of Class. Neal isn't either but
      // suspects some pathological case related to nested classes exists.
      Type rawType = parameterizedType.getRawType();
      if (!(rawType instanceof Class)) throw new IllegalArgumentException();
      return (Class<?>) rawType;
    }
    if (type instanceof GenericArrayType) {
      Type componentType = ((GenericArrayType) type).getGenericComponentType();
      return Array.newInstance(getRawType(componentType), 0).getClass();
    }
    if (type instanceof TypeVariable) {
      // We could use the variable's bounds, but that won't work if there are multiple. Having a raw
      // type that's more general than necessary is okay.
      return Object.class;
    }
    if (type instanceof WildcardType) {
      return getRawType(((WildcardType) type).getUpperBounds()[0]);
    }

    throw new IllegalArgumentException("Expected a Class, ParameterizedType, or "
          + "GenericArrayType, but <" + type + "> is of type " + type.getClass().getName());
  }

（2）、ParameterizedType接口

ParameterizedType 表示参数化类型，也就是泛型，如 Collection<String>。
如：

Map<String, Person> map;
Set<String> set1;
Class<?> clz;
Holder<String> holder;
List<String> list;

ParameterizedType 接口提供了三个方法：

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

前两个方法比较常见，以Map<String, Person> map为例，getActualTypeArguments()获取的是String和Person类型的集合。getRawType()是获取到Map类型。

public class ParameterizedTest<T> {
    
    // map对象
    public Map<T,Integer> map;

    public static void main(String[] args) throws Exception{
        
        // 通过反射解析map对象
        Field field = ParameterizedTest.class.getDeclaredField("map");
        Type type =field.getGenericType();
        // 是ParameterizedType类型
        if (type instanceof ParameterizedType) {
            // 1
            Type[] typeArguments = ((ParameterizedType) type).getActualTypeArguments();
            for (Type t : typeArguments) {
                // 参数是TypeVariable
                if (t instanceof TypeVariable) { // T 是 TypeVariable类型
                    System.out.println("TypeVariable: "+((TypeVariable) t).getName());
                } else if (t instanceof Class<?>) { // Integer是Class<?> 原始类型
                    System.out.println("Class<?>: "+t);
                }
            }
            
            // 2、
            Type rawType = ((ParameterizedType) type).getRawType();
            System.out.println("ParameterizedType: "+rawType);
        }
    }
}

结果：
TypeVariable: T
Class<?>: class java.lang.Integer
ParameterizedType: interface java.util.Map

（3）、TypeVariable接口

类型变量，例如：T、K、V等变量。TypeVariable代表着泛型中的变量，而ParameterizedType则代表整个泛型。
接口方法：

Type[] getBounds(); // 得到上限的泛型
D getGenericDeclaration(); // 获取声明该类型变量实体(是Class, Constructor, Method)
String getName(); // 获取名字

public class TypeVariableTest<T> {

    public static void main(String[] args) {
        // 得到T
        TypeVariable<?>[] typeParameters = TypeVariableTest.class.getTypeParameters();
        for (TypeVariable type : typeParameters) {
            System.out.println(type.getGenericDeclaration());  // 查看是哪里申明的
            System.out.println(type.getName());
            System.out.println();
            
            Type[] boundTypes = type.getBounds();
            for (Type boundType : boundTypes) {
                System.out.println(boundType);
            }
        }
    }
}

结果：
class JavaFinal.TypeVariableTest
T

class java.lang.Object

从D getGenericDeclaration()来看，可以在哪些地方声明泛型T了？
需要了解到GenericDeclaration这个接口，这是个声明泛型的接口

GenericDeclaration继承关系

由结构可以看出，一共有三个地方可以声明泛型。

类： TypeVariableTest<T>
方法： <T> void print(T t)
构造方法： public <T> TypeVariableTest()

（4）、GenericArrayType接口

泛型数组。它的组成元素是ParameterizedType或TypeVariable 类型。
接口方法：

Type getGenericComponentType(); // 返回泛型数组中元素的Type类型，即T[] 中的T（TypeVariableImpl）

下列是几个GenericArrayType泛型例子：

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

Retrofit中的例子：

    if (type instanceof GenericArrayType) {
      Type componentType = ((GenericArrayType) type).getGenericComponentType();
      return Array.newInstance(getRawType(componentType), 0).getClass();
    }

（5）、WildcardType

通配符泛型。这个一般不太常使用。只是获取通配符的上限泛型处理。

    if (type instanceof WildcardType) {
      return getRawType(((WildcardType) type).getUpperBounds()[0]);
    }