TypeKit (bus-core 6.0.2 API)

java.lang.Object
- org.aoju.bus.core.toolkit.TypeKit

public class TypeKit
extends Object

针对 Type 的工具类封装最主要功能包括：

 1. 获取方法的参数和返回值类型(包括Type和Class)
 2. 获取泛型参数类型(包括对象的泛型参数或集合元素的泛型类型)

Since:: JDK 1.8+
Version:: 6.0.2
Author:: Kimi Liu

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class TypeKit.WildcardTypeBuilder

Nested Classes
Modifier and Type	Class and Description
`static class`	`TypeKit.WildcardTypeBuilder`

Constructor Summary

Constructors
Constructor and Description

TypeKit()

Constructors
Constructor and Description
`TypeKit()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static boolean`	`containsTypeVariables(Type type)` 递归比较与`type`关联的任何类型参数是否绑定到变量.
`static Map<TypeVariable<?>,Type>`	`determineTypeArguments(Class<?> cls, ParameterizedType superType)` 尝试基于超参数化类型的类型参数确定类/接口的类型参数
`static boolean`	`equals(Type t1, Type t2)` 检查类型是否相等
`static GenericArrayType`	`genericArrayType(Type componentType)` 创建泛型数组类型实例.
`static Type`	`getActualType(Type actualType, Class<?> typeDefineClass, Type typeVariable)` 获取指定泛型变量对应的真实类型由于子类中泛型参数实现和父类(接口)中泛型定义位置是一一对应的,因此可以通过对应关系找到泛型实现类型使用此方法注意：
`static Type[]`	`getActualTypes(Type actualType, Class<?> typeDefineClass, Type... typeVariables)` 获取指定泛型变量对应的真实类型由于子类中泛型参数实现和父类(接口)中泛型定义位置是一一对应的,因此可以通过对应关系找到泛型实现类型使用此方法注意：
`static Type`	`getArrayComponentType(Type type)` 获取数组组件类型为`type`.
`static Class<?>`	`getClass(Field field)` 获得Field对应的原始类
`static Class<?>`	`getClass(Type type)` 获得Type对应的原始类
`static Class<?>`	`getFirstParamClass(Method method)` 获取方法的第一个参数类
`static Type`	`getFirstParamType(Method method)` 获取方法的第一个参数类型优先获取方法的GenericParameterTypes,如果获取不到,则获取ParameterTypes
`static Type[]`	`getImplicitBounds(TypeVariable<?> typeVariable)` 如果`TypeVariable.getBounds()`返回一个空数组, 则返回一个包含`Object` 唯一类型的数组.
`static Type[]`	`getImplicitLowerBounds(WildcardType wildcardType)` 如果`WildcardType.getLowerBounds()`返回一个空数组，则返回一个包含单个值`null`的数组。否则，它将返回`WildcardType.getLowerBounds()`的结果.
`static Type[]`	`getImplicitUpperBounds(WildcardType wildcardType)` 如果`WildcardType.getUpperBounds()`返回一个空数组，则返回一个包含`Object`唯一值的数组。否则，它将返回传递给`normalizeUpperBounds(java.lang.reflect.Type[])`的 `WildcardType.getUpperBounds()`的结果
`static Class`	`getListType(Field field)` 获取列表字段对应的类型
`static Class<?>`	`getParamClass(Method method, int index)` 获取方法的参数类
`static Class<?>[]`	`getParamClasses(Method method)` 解析方法的参数类型列表依赖jre\lib\rt.jar
`static Type`	`getParamType(Method method, int index)` 获取方法的参数类型优先获取方法的GenericParameterTypes,如果获取不到,则获取ParameterTypes
`static Type[]`	`getParamTypes(Method method)` 获取方法的参数类型列表优先获取方法的GenericParameterTypes,如果获取不到,则获取ParameterTypes
`static Class<?>`	`getRawType(Type type, Type assigningType)` 根据上下文获取Java类型的原始类型主要用于`TypeVariable`s和`GenericArrayType`
`static Class<?>`	`getReturnClass(Method method)` 解析方法的返回类型类列表
`static Type`	`getReturnType(Method method)` 获取方法的返回值类型获取方法的GenericReturnType
`static Type`	`getType(Field field)` 获取字段对应的Type类型方法优先获取GenericType,获取不到则获取Type
`static Type`	`getTypeArgument(Class<?> clazz)` 获得给定类的第一个泛型参数
`static Type`	`getTypeArgument(Class<?> clazz, int index)` 获得给定类的泛型参数
`static Type`	`getTypeArgument(Type type)` 获得给定类的第一个泛型参数
`static Type`	`getTypeArgument(Type type, int index)` 获得给定类的泛型参数
`static Map<TypeVariable<?>,Type>`	`getTypeArguments(ParameterizedType type)` 检索此参数化类型的所有类型参数，包括所有者层次结构参数
`static Type[]`	`getTypeArguments(Type type)` 获得指定类型中所有泛型参数类型
`static Map<TypeVariable<?>,Type>`	`getTypeArguments(Type type, Class<?> toClass)` 获取基于子类型的类/接口的类型参数
`static boolean`	`hasTypeVeriable(Type... types)` 指定泛型数组中是否含有泛型变量
`static boolean`	`isAbstract(Class<?> clazz)` 是否为抽象类
`static boolean`	`isAbstractOrInterface(Class<?> clazz)` 是抽象类或者接口
`static boolean`	`isArray(Class<?> clazz)` 是否为数组 class 类型
`static boolean`	`isArrayType(Type type)` 了解指定的类型是否表示数组类型。
`static boolean`	`isAssignable(Type type, Type toType)` 检查subject类型是否可以按照Java泛型规则隐式转换为目标类型.
`static boolean`	`isBase(Class<?> clazz)` 是否为基本类型 1.
`static boolean`	`isBean(Class<?> clazz)` 判断是否为Bean对象判定方法是是否存在只有一个参数的setXXX方法
`static boolean`	`isCollection(Class<?> clazz)` 是否为 Collection class 类型
`static boolean`	`isInstance(Object value, Type type)` 检查给定值是否可以按照Java泛型规则分配给目标类型
`static boolean`	`isIterable(Class<?> clazz)` 是否为 Iterable class 类型
`static boolean`	`isJavaBean(Class<?> clazz)` 是否为标准的类这个类必须：
`static boolean`	`isJdk(Class<?> clazz)` 判断一个类是JDK 自带的类型 jdk 自带的类,classLoader 是为空的
`static boolean`	`isList(Class clazz)` 是否为列表
`static boolean`	`isMap(Class<?> clazz)` 是否为 map class 类型
`static boolean`	`isSet(Class clazz)` 是否为 set
`static boolean`	`isUnknow(Type type)` 是否未知类型 type为null或者`TypeVariable` 都视为未知类型
`static boolean`	`isWildcardGenericType(Type type)` 是否为通配符泛型
`static Type[]`	`normalizeUpperBounds(Type[] bounds)` 该方法在类型变量类型和通配符类型中去除冗余的上界类型
`static ParameterizedType`	`parameterize(Class<?> raw, Map<TypeVariable<?>,Type> typeArgMappings)` 创建参数化类型实例.
`static ParameterizedType`	`parameterize(Class<?> raw, Type... typeArguments)` 创建参数化类型实例.
`static ParameterizedType`	`parameterizeWithOwner(Type owner, Class<?> raw, Map<TypeVariable<?>,Type> typeArgMappings)` 创建参数化类型实例.
`static ParameterizedType`	`parameterizeWithOwner(Type owner, Class<?> raw, Type... typeArguments)` 创建参数化类型实例.
`static String`	`toLongString(TypeVariable<?> var)` 格式化一个`TypeVariable`，包括它的`GenericDeclaration`
`static ParameterizedType`	`toParameterizedType(Type type)` 将`Type` 转换为`ParameterizedType` `ParameterizedType`用于获取当前类或父类中泛型参数化后的类型一般用于获取泛型参数具体的参数类型,例如：
`static String`	`toString(Type type)` 将给定的类型表示为java风格的字符串.
`static boolean`	`typesSatisfyVariables(Map<TypeVariable<?>,Type> typeVarAssigns)` 确定指定的类型，是否满类型变量的边界
`static Type`	`unrollVariables(Map<TypeVariable<?>,Type> typeArguments, Type type)` 获取一个表示`type`的类型，该类型具有“展开”的变量赋值。
`static TypeKit.WildcardTypeBuilder`	`wildcardType()` 获取`TypeKit.WildcardTypeBuilder`.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - TypeKit
```
public TypeKit()
```
- Method Detail
  - isMap
```
public static boolean isMap(Class<?> clazz)
```
    是否为 map class 类型
    
    Parameters:
    
    clazz - 对象类型
    
    Returns:
    
    是否为 map class
  - isArray
```
public static boolean isArray(Class<?> clazz)
```
    是否为数组 class 类型
    
    Parameters:
    
    clazz - 对象类型
    
    Returns:
    
    是否为数组 class
  - isCollection
```
public static boolean isCollection(Class<?> clazz)
```
    是否为 Collection class 类型
    
    Parameters:
    
    clazz - 对象类型
    
    Returns:
    
    是否为 Collection class
  - isIterable
```
public static boolean isIterable(Class<?> clazz)
```
    是否为 Iterable class 类型
    
    Parameters:
    
    clazz - 对象类型
    
    Returns:
    
    是否为数组 class
  - isBase
```
public static boolean isBase(Class<?> clazz)
```
    是否为基本类型 1. 8大基本类型 2. 常见的值类型
    
    Parameters:
    
    clazz - 对象类型
    
    Returns:
    
    是否为基本类型
  - isAbstract
```
public static boolean isAbstract(Class<?> clazz)
```
    是否为抽象类
    
    Parameters:
    
    clazz - 类
    
    Returns:
    
    是否为抽象类
  - isAbstractOrInterface
```
public static boolean isAbstractOrInterface(Class<?> clazz)
```
    是抽象类或者接口
    
    Parameters:
    
    clazz - 类信息
    
    Returns:
    
    是否
  - isJavaBean
```
public static boolean isJavaBean(Class<?> clazz)
```
    是否为标准的类这个类必须：
```
 0、不为 null
 1、非接口
 2、非抽象类
 3、非Enum枚举
 4、非数组
 5、非注解
 6、非原始类型(int, long等)
 7、非集合 Iterable
 8、非 Map.clas
 9、非 JVM 生成类
 
```
    Parameters:
    
    clazz - 类
    
    Returns:
    
    是否为标准类
  - isJdk
```
public static boolean isJdk(Class<?> clazz)
```
    判断一个类是JDK 自带的类型 jdk 自带的类,classLoader 是为空的
    
    Parameters:
    
    clazz - 类
    
    Returns:
    
    是否为 java 类
  - isBean
```
public static boolean isBean(Class<?> clazz)
```
    判断是否为Bean对象判定方法是是否存在只有一个参数的setXXX方法
    
    Parameters:
    
    clazz - 待测试类
    
    Returns:
    
    是否为Bean对象
  - getClass
```
public static Class<?> getClass(Type type)
```
    获得Type对应的原始类
    
    Parameters:
    
    type - Type
    
    Returns:
    
    原始类, 如果无法获取原始类, 返回null
  - getFirstParamType
```
public static Type getFirstParamType(Method method)
```
    获取方法的第一个参数类型优先获取方法的GenericParameterTypes,如果获取不到,则获取ParameterTypes
    
    Parameters:
    
    method - 方法
    
    Returns:
    
    Type,可能为null
  - getFirstParamClass
```
public static Class<?> getFirstParamClass(Method method)
```
    获取方法的第一个参数类
    
    Parameters:
    
    method - 方法
    
    Returns:
    
    第一个参数类型, 可能为null
  - getParamType
```
public static Type getParamType(Method method,
                                int index)
```
    获取方法的参数类型优先获取方法的GenericParameterTypes,如果获取不到,则获取ParameterTypes
    
    Parameters:
    
    method - 方法
    
    index - 第几个参数的索引,从0开始计数
    
    Returns:
    
    Type,可能为null
  - getParamClass
```
public static Class<?> getParamClass(Method method,
                                     int index)
```
    获取方法的参数类
    
    Parameters:
    
    method - 方法
    
    index - 第几个参数的索引,从0开始计数
    
    Returns:
    
    参数类, 可能为null
  - getTypeArgument
```
public static Type getTypeArgument(Type type)
```
    获得给定类的第一个泛型参数
    
    Parameters:
    
    type - 被检查的类型,必须是已经确定泛型类型的类型
    
    Returns:
    
    Type,可能为null
  - getTypeArgument
```
public static Type getTypeArgument(Type type,
                                   int index)
```
    获得给定类的泛型参数
    
    Parameters:
    
    type - 被检查的类型,必须是已经确定泛型类型的类
    
    index - 泛型类型的索引号,既第几个泛型类型
    
    Returns:
    
    Type
  - toParameterizedType
```
public static ParameterizedType toParameterizedType(Type type)
```
    将Type 转换为ParameterizedType ParameterizedType用于获取当前类或父类中泛型参数化后的类型一般用于获取泛型参数具体的参数类型,例如：
```
 class A<T>
 class B extends A<String>
 
```
    通过此方法,传入B.class即可得到BParameterizedType,从而获取到String
    Parameters:
    
    type - Type
    
    Returns:
    
    ParameterizedType
  - getActualTypes
```
public static Type[] getActualTypes(Type actualType,
                                    Class<?> typeDefineClass,
                                    Type... typeVariables)
```
    获取指定泛型变量对应的真实类型由于子类中泛型参数实现和父类(接口)中泛型定义位置是一一对应的,因此可以通过对应关系找到泛型实现类型使用此方法注意：
```
 1. superClass必须是clazz的父类或者clazz实现的接口
 2. typeVariable必须在superClass中声明
 
```
    Parameters:
    
    actualType - 真实类型所在类,此类中记录了泛型参数对应的实际类型
    
    typeDefineClass - 泛型变量声明所在类或接口,此类中定义了泛型类型
    
    typeVariables - 泛型变量,需要的实际类型对应的泛型参数
    
    Returns:
    
    给定泛型参数对应的实际类型, 如果无对应类型, 返回null
  - getActualType
```
public static Type getActualType(Type actualType,
                                 Class<?> typeDefineClass,
                                 Type typeVariable)
```
    获取指定泛型变量对应的真实类型由于子类中泛型参数实现和父类(接口)中泛型定义位置是一一对应的,因此可以通过对应关系找到泛型实现类型使用此方法注意：
```
 1. superClass必须是clazz的父类或者clazz实现的接口
 2. typeVariable必须在superClass中声明
 
```
    Parameters:
    
    actualType - 真实类型所在类,此类中记录了泛型参数对应的实际类型
    
    typeDefineClass - 泛型变量声明所在类或接口,此类中定义了泛型类型
    
    typeVariable - 泛型变量,需要的实际类型对应的泛型参数
    
    Returns:
    
    给定泛型参数对应的实际类型
  - isUnknow
```
public static boolean isUnknow(Type type)
```
    是否未知类型 type为null或者TypeVariable 都视为未知类型
    
    Parameters:
    
    type - Type类型
    
    Returns:
    
    是否未知类型
  - hasTypeVeriable
```
public static boolean hasTypeVeriable(Type... types)
```
    指定泛型数组中是否含有泛型变量
    
    Parameters:
    
    types - 泛型数组
    
    Returns:
    
    是否含有泛型变量
  - getListType
```
public static Class getListType(Field field)
```
    获取列表字段对应的类型
    
    Parameters:
    
    field - 字段
    
    Returns:
    
    返回对应的 class 类型
  - isWildcardGenericType
```
public static boolean isWildcardGenericType(Type type)
```
    是否为通配符泛型
    
    Parameters:
    
    type - 类型
    
    Returns:
    
    是否
  - isList
```
public static boolean isList(Class clazz)
```
    是否为列表
    
    Parameters:
    
    clazz - 类型
    
    Returns:
    
    结果
  - isSet
```
public static boolean isSet(Class clazz)
```
    是否为 set
    
    Parameters:
    
    clazz - 类型
    
    Returns:
    
    结果
  - getType
```
public static Type getType(Field field)
```
    获取字段对应的Type类型方法优先获取GenericType,获取不到则获取Type
    
    Parameters:
    
    field - 字段
    
    Returns:
    
    Type,可能为null
  - getClass
```
public static Class<?> getClass(Field field)
```
    获得Field对应的原始类
    
    Parameters:
    
    field - Field
    
    Returns:
    
    原始类, 如果无法获取原始类, 返回null
  - getParamTypes
```
public static Type[] getParamTypes(Method method)
```
    获取方法的参数类型列表优先获取方法的GenericParameterTypes,如果获取不到,则获取ParameterTypes
    
    Parameters:
    
    method - 方法
    
    Returns:
    
    Type列表,可能为null
    
    See Also:
    
    Method.getGenericParameterTypes(), Method.getParameterTypes()
  - getParamClasses
```
public static Class<?>[] getParamClasses(Method method)
```
    解析方法的参数类型列表依赖jre\lib\rt.jar
    
    Parameters:
    
    method - t方法
    
    Returns:
    
    参数类型类列表
    
    See Also:
    
    Method.getGenericParameterTypes(), Method.getParameterTypes()
  - getReturnType
```
public static Type getReturnType(Method method)
```
    获取方法的返回值类型获取方法的GenericReturnType
    
    Parameters:
    
    method - 方法
    
    Returns:
    
    Type,可能为null
    
    See Also:
    
    Method.getGenericReturnType(), Method.getReturnType()
  - getReturnClass
```
public static Class<?> getReturnClass(Method method)
```
    解析方法的返回类型类列表
    
    Parameters:
    
    method - 方法
    
    Returns:
    
    返回值类型的类
    
    See Also:
    
    Method.getGenericReturnType(), Method.getReturnType()
  - getTypeArgument
```
public static Type getTypeArgument(Class<?> clazz)
```
    获得给定类的第一个泛型参数
    
    Parameters:
    
    clazz - 被检查的类,必须是已经确定泛型类型的类
    
    Returns:
    
    Type,可能为null
  - getTypeArgument
```
public static Type getTypeArgument(Class<?> clazz,
                                   int index)
```
    获得给定类的泛型参数
    
    Parameters:
    
    clazz - 被检查的类,必须是已经确定泛型类型的类
    
    index - 泛型类型的索引号,既第几个泛型类型
    
    Returns:
    
    Type
  - getTypeArguments
```
public static Type[] getTypeArguments(Type type)
```
    获得指定类型中所有泛型参数类型
    
    Parameters:
    
    type - 指定类型
    
    Returns:
    
    所有泛型参数类型
  - isAssignable
```
public static boolean isAssignable(Type type,
                                   Type toType)
```
    检查subject类型是否可以按照Java泛型规则隐式转换为目标类型. 如果这两种类型都是Class对象，则该方法返回ClassKit.isAssignable(Class, Class)的结果
    
    Parameters:
    
    type - 要分配给目标类型的主题类型
    
    toType - 目标类型
    
    Returns:
    
    如果type可赋值给toType，则true.
  - getTypeArguments
```
public static Map<TypeVariable<?>,Type> getTypeArguments(ParameterizedType type)
```
    检索此参数化类型的所有类型参数，包括所有者层次结构参数
    
    Parameters:
    
    type - 指定要从中获取参数的主题参数化类型
    
    Returns:
    
    带有类型参数的Map.
  - getTypeArguments
```
public static Map<TypeVariable<?>,Type> getTypeArguments(Type type,
                                                         Class<?> toClass)
```
    获取基于子类型的类/接口的类型参数
    
    Parameters:
    
    type - 用于确定toClass的类型参数的类型
    
    toClass - 类型参数将根据子类型type确定的类
    
    Returns:
    
    带有类型参数的Map
  - determineTypeArguments
```
public static Map<TypeVariable<?>,Type> determineTypeArguments(Class<?> cls,
                                                               ParameterizedType superType)
```
    尝试基于超参数化类型的类型参数确定类/接口的类型参数
    
    Parameters:
    
    cls - 要确定类型参数的类
    
    superType - 要从中确定cls的类型参数的超类型
    
    Returns:
    
    类型赋值的Map，可以确定继承层次结构中从type到toClass的每个类型中的类型变量.
  - isInstance
```
public static boolean isInstance(Object value,
                                 Type type)
```
    检查给定值是否可以按照Java泛型规则分配给目标类型
    
    Parameters:
    
    value - 要检查的值
    
    type - 目标类型
    
    Returns:
    
    如果value是type的实例，则true.
  - normalizeUpperBounds
```
public static Type[] normalizeUpperBounds(Type[] bounds)
```
    该方法在类型变量类型和通配符类型中去除冗余的上界类型
    
    Parameters:
    
    bounds - 表示WildcardType或 TypeVariable的上界的类型数组.
    
    Returns:
    
    包含来自bounds的值减去冗余类型的数组.
  - getImplicitBounds
```
public static Type[] getImplicitBounds(TypeVariable<?> typeVariable)
```
    如果TypeVariable.getBounds()返回一个空数组, 则返回一个包含Object 唯一类型的数组. 否则返回TypeVariable.getBounds() 传递给normalizeUpperBounds(java.lang.reflect.Type[])的结果
    
    Parameters:
    
    typeVariable - 类型变量
    
    Returns:
    
    包含类型变量边界的非空数组.
  - getImplicitUpperBounds
```
public static Type[] getImplicitUpperBounds(WildcardType wildcardType)
```
    如果WildcardType.getUpperBounds()返回一个空数组，则返回一个包含Object唯一值的数组。否则，它将返回传递给normalizeUpperBounds(java.lang.reflect.Type[])的 WildcardType.getUpperBounds()的结果
    
    Parameters:
    
    wildcardType - 通配符类型
    
    Returns:
    
    包含通配符类型下界的非空数组.
  - getImplicitLowerBounds
```
public static Type[] getImplicitLowerBounds(WildcardType wildcardType)
```
    如果WildcardType.getLowerBounds()返回一个空数组，则返回一个包含单个值null的数组。否则，它将返回WildcardType.getLowerBounds()的结果.
    
    Parameters:
    
    wildcardType - 通配符类型
    
    Returns:
    
    包含通配符类型下界的非空数组.
  - typesSatisfyVariables
```
public static boolean typesSatisfyVariables(Map<TypeVariable<?>,Type> typeVarAssigns)
```
    确定指定的类型，是否满类型变量的边界
    
    Parameters:
    
    typeVarAssigns - 指定分配给类型变量的潜在类型，而不是null.
    
    Returns:
    
    是否可以将类型分配给它们各自的类型变量.
  - getRawType
```
public static Class<?> getRawType(Type type,
                                  Type assigningType)
```
    根据上下文获取Java类型的原始类型主要用于TypeVariables和GenericArrayType
    
    Parameters:
    
    type - 类型
    
    assigningType - 要解析的类型
    
    Returns:
    
    如果不能解析类型，则解析Class对象或null
  - isArrayType
```
public static boolean isArrayType(Type type)
```
    了解指定的类型是否表示数组类型。
    
    Parameters:
    
    type - 要检查的类型
    
    Returns:
    
    如果type是数组类或GenericArrayType，则为true
  - getArrayComponentType
```
public static Type getArrayComponentType(Type type)
```
    获取数组组件类型为type.
    
    Parameters:
    
    type - 要检查的类型
    
    Returns:
    
    如果类型不是数组类型，则为null
  - unrollVariables
```
public static Type unrollVariables(Map<TypeVariable<?>,Type> typeArguments,
                                   Type type)
```
    获取一个表示type的类型，该类型具有“展开”的变量赋值。
    
    Parameters:
    
    typeArguments - 参数 getTypeArguments(Type, Class)
    
    type - 变量赋值的类型
    
    Returns:
    
    Type
  - containsTypeVariables
```
public static boolean containsTypeVariables(Type type)
```
    递归比较与type关联的任何类型参数是否绑定到变量.
    
    Parameters:
    
    type - 检查类型变量的类型
    
    Returns:
    
    boolean
  - parameterize
```
public static final ParameterizedType parameterize(Class<?> raw,
                                                   Type... typeArguments)
```
    创建参数化类型实例.
    
    Parameters:
    
    raw - 用于创建参数化类型实例的原始类
    
    typeArguments - 用于参数化的类型
    
    Returns:
    
    ParameterizedType
  - parameterize
```
public static final ParameterizedType parameterize(Class<?> raw,
                                                   Map<TypeVariable<?>,Type> typeArgMappings)
```
    创建参数化类型实例.
    
    Parameters:
    
    raw - 用于创建参数化类型实例的原始类
    
    typeArgMappings - 用于参数化的类型
    
    Returns:
    
    ParameterizedType
  - parameterizeWithOwner
```
public static final ParameterizedType parameterizeWithOwner(Type owner,
                                                            Class<?> raw,
                                                            Type... typeArguments)
```
    创建参数化类型实例.
    
    Parameters:
    
    owner - 类型
    
    raw - 用于创建参数化类型实例的原始类
    
    typeArguments - 用于参数化的类型
    
    Returns:
    
    ParameterizedType
  - parameterizeWithOwner
```
public static final ParameterizedType parameterizeWithOwner(Type owner,
                                                            Class<?> raw,
                                                            Map<TypeVariable<?>,Type> typeArgMappings)
```
    创建参数化类型实例.
    
    Parameters:
    
    owner - 类型
    
    raw - 用于创建参数化类型实例的原始类
    
    typeArgMappings - 用于参数化的映射
    
    Returns:
    
    ParameterizedType
  - wildcardType
```
public static TypeKit.WildcardTypeBuilder wildcardType()
```
    获取TypeKit.WildcardTypeBuilder.
    
    Returns:
    
    TypeKit.WildcardTypeBuilder
  - genericArrayType
```
public static GenericArrayType genericArrayType(Type componentType)
```
    创建泛型数组类型实例.
    
    Parameters:
    
    componentType - 数组元素的类型
    
    Returns:
    
    GenericArrayType
  - equals
```
public static boolean equals(Type t1,
                             Type t2)
```
    检查类型是否相等
    
    Parameters:
    
    t1 - 第一个比较对象
    
    t2 - 第二个比较对象
    
    Returns:
    
    是否相等 true/false
  - toString
```
public static String toString(Type type)
```
    将给定的类型表示为java风格的字符串.
    
    Parameters:
    
    type - 创建字符串表示的类型
    
    Returns:
    
    字符串
  - toLongString
```
public static String toLongString(TypeVariable<?> var)
```
    格式化一个TypeVariable，包括它的GenericDeclaration
    
    Parameters:
    
    var - 创建字符串表示的类型变量，而不是null
    
    Returns:
    
    字符串

Class TypeKit

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

TypeKit

Method Detail

isMap

isArray

isCollection

isIterable

isBase

isAbstract

isAbstractOrInterface

isJavaBean

isJdk

isBean

getClass

getFirstParamType

getFirstParamClass

getParamType

getParamClass

getTypeArgument

getTypeArgument

toParameterizedType

getActualTypes

getActualType

isUnknow

hasTypeVeriable

getListType

isWildcardGenericType

isList

isSet

getType

getClass

getParamTypes

getParamClasses

getReturnType

getReturnClass

getTypeArgument

getTypeArgument

getTypeArguments

isAssignable

getTypeArguments

getTypeArguments

determineTypeArguments

isInstance

normalizeUpperBounds

getImplicitBounds

getImplicitUpperBounds

getImplicitLowerBounds

typesSatisfyVariables

getRawType

isArrayType

getArrayComponentType

unrollVariables

containsTypeVariables

parameterize

parameterize

parameterizeWithOwner

parameterizeWithOwner

wildcardType

genericArrayType

equals

toString

toLongString