javax.lang.model.util

接口
类

javax.lang.model.util
接口 Types

public interface Types

用来对类型进行操作的实用工具方法。

兼容性注意事项： 在将来的平台版本中可能会向此接口添加一些方法。

从以下版本开始：
1.6
另请参见：
ProcessingEnvironment.getTypeUtils()

方法摘要
 Element asElement(TypeMirror t)
          返回对应于类型的元素。
 TypeMirror asMemberOf(DeclaredType containing, Element element)
          当元素被视为给定类型的成员或者直接由给定类型包含时，返回该元素的类型。
 TypeElement boxedClass(PrimitiveType p)
          返回给定基本类型的装箱 (boxed) 值类型的类。
 TypeMirror capture(TypeMirror t)
          对类型应用 capture 转换。
 boolean contains(TypeMirror t1, TypeMirror t2)
          测试一个类型参数是否包含 另一个类型参数。
 List<? extends TypeMirror> directSupertypes(TypeMirror t)
          返回类型的直接超类型。
 TypeMirror erasure(TypeMirror t)
          返回删除状态的类型。
 ArrayType getArrayType(TypeMirror componentType)
          返回具有指定组件类型的数组类型。
 DeclaredType getDeclaredType(DeclaredType containing, TypeElement typeElem, TypeMirror... typeArgs)
          根据给定的包含类型，返回对应于类型元素和实际类型参数的类型（它是给定包含类型的成员）。
 DeclaredType getDeclaredType(TypeElement typeElem, TypeMirror... typeArgs)
          返回对应于类型元素和实际类型参数的类型。
 NoType getNoType(TypeKind kind)
          返回在实际类型不适用的地方所使用的伪类型。
 NullType getNullType()
          返回 null 类型。
 PrimitiveType getPrimitiveType(TypeKind kind)
          返回基本类型。
 WildcardType getWildcardType(TypeMirror extendsBound, TypeMirror superBound)
          返回新的通配符类型参数。
 boolean isAssignable(TypeMirror t1, TypeMirror t2)
          测试一种类型是否可以指派给另一种类型。
 boolean isSameType(TypeMirror t1, TypeMirror t2)
          测试两个 TypeMirror 对象是否表示同一类型。
 boolean isSubsignature(ExecutableType m1, ExecutableType m2)
          测试一个方法的签名是否是另一个方法的子签名。
 boolean isSubtype(TypeMirror t1, TypeMirror t2)
          测试一种类型是否是另一个类型的子类型。
 PrimitiveType unboxedType(TypeMirror t)
          返回给定类型的拆箱 (unboxed) 值类型（基本类型）。
 

方法详细信息

asElement

Element asElement(TypeMirror t)
返回对应于类型的元素。该类型可能是 DeclaredType 或 TypeVariable。如果该类型没有对应元素，则返回 null。

返回：
对应于给定类型的元素

isSameType

boolean isSameType(TypeMirror t1,
                   TypeMirror t2)
测试两个 TypeMirror 对象是否表示同一类型。

警告：如果此方法两个参数中有一个表示通配符，那么此方法将返回 false。因此，通配符与其本身的类型不同。初看起来这可能让人感到很奇怪，但考虑到编译器一定会拒绝以下示例时，这就很合理了： 

 
List<?> list = new ArrayList<Object>();
list.add(list.get(0));

参数：
t1 - 第一种类型
t2 - 第二种类型
返回：
当且仅当两种类型相同时返回 true

isSubtype

boolean isSubtype(TypeMirror t1,
                  TypeMirror t2)
测试一种类型是否是另一个类型的子类型。任何类型都被认为是其本身的子类型。

参数：
t1 - 第一种类型
t2 - 第二种类型
返回：
当且仅当第一种类型是第二种类型的子类型时返回 true
抛出：
IllegalArgumentException - 如果给定一个 executable 或 package 类型

isAssignable

boolean isAssignable(TypeMirror t1,
                     TypeMirror t2)
测试一种类型是否可以指派给另一种类型。

参数：
t1 - 第一种类型
t2 - 第二种类型
返回：
当且仅当第一种类型可以指派给第二种类型时返回 true
抛出：
IllegalArgumentException - 如果给定一个 executable 或 package 类型

contains

boolean contains(TypeMirror t1,
                 TypeMirror t2)
测试一个类型参数是否 包含 另一个类型参数。

参数：
t1 - 第一种类型
t2 - 第二种类型
返回：
当且仅当第一种类型包含第二种类型时返回 true
抛出：
IllegalArgumentException - 如果给定一个 executable 或 package 类型

isSubsignature

boolean isSubsignature(ExecutableType m1,
                       ExecutableType m2)
测试一个方法的签名是否是另一个方法的 子签名。

参数：
m1 - 第一个方法
m2 - 第二个方法
返回：
当且仅当第一个签名是第二个签名的子签名时返回 true

directSupertypes

List<? extends TypeMirror> directSupertypes(TypeMirror t)
返回类型的直接超类型。interface 类型将出现在列表的最后（如果有）。

参数：
t - 将被检查的类型
返回：
直接超类型；如果没有，则返回一个空列表
抛出：
IllegalArgumentException - 如果给定一个 executable 或 package 类型

erasure

TypeMirror erasure(TypeMirror t)
返回删除状态的类型。

参数：
t - 要删除的类型
返回：
删除状态的给定类型
抛出：
IllegalArgumentException - 如果给定一个 package 类型

boxedClass

TypeElement boxedClass(PrimitiveType p)
返回给定基本类型的装箱 (boxed) 值类型的类。即应用 boxing 转换。

参数：
p - 要转换的基本类型
返回：
类型 p 的装箱值类型的类

unboxedType

PrimitiveType unboxedType(TypeMirror t)
返回给定类型的拆箱 (unboxed) 值类型（基本类型）。即应用 unboxing 转换。

参数：
t - 要拆箱的类型
返回：
类型 t 的拆箱值类型
抛出：
IllegalArgumentException - 如果给定类型无法进行 unboxing 转换

capture

TypeMirror capture(TypeMirror t)
对类型应用 capture 转换。

参数：
t - 要转换的类型
返回：
应用 capture 转换的结果
抛出：
IllegalArgumentException - 如果给定 executable 或 package 类型

getPrimitiveType

PrimitiveType getPrimitiveType(TypeKind kind)
返回基本类型。

参数：
kind - 要返回的基本类型的种类
返回：
一个基本类型
抛出：
IllegalArgumentException - 如果 kind 不是基本种类

getNullType

NullType getNullType()
返回 null 类型。该类型是 null 的类型。

返回：
null 类型

getNoType

NoType getNoType(TypeKind kind)
返回在实际类型不适用的地方所使用的伪类型。要返回的类型的种类可以是 VOID 或 NONE。对于包，可以使用 Elements.getPackageElement(CharSequence) .asType() 替代。

参数：
kind - 要返回的类型的种类
返回：
种类 VOID 或 NONE 的伪类型
抛出：
IllegalArgumentException - 如果 kind 无效

getArrayType

ArrayType getArrayType(TypeMirror componentType)
返回具有指定组件类型的数组类型。

参数：
componentType - 组件类型
返回：
具有指定组件类型的数组类型。
抛出：
IllegalArgumentException - 如果组件类型对于数组无效

getWildcardType

WildcardType getWildcardType(TypeMirror extendsBound,
                             TypeMirror superBound)
返回新的通配符类型参数。可以指定通配符边界中的一个，也可以都不指定，但不能都指定。

参数：
extendsBound - 扩展（上）边界；如果没有，则该参数为 null
superBound - 超（下）边界；如果没有，则该参数为 null
返回：
新的通配符
抛出：
IllegalArgumentException - 如果边界无效

getDeclaredType

DeclaredType getDeclaredType(TypeElement typeElem,
                             TypeMirror... typeArgs)
返回对应于类型元素和实际类型参数的类型。例如，如果给定 Set 的类型元素和 String 的类型镜像，那么可以使用此方法获取参数化类型 Set<String>。

类型参数的数量必须等于类型元素的形式类型参数的数量，或者等于 0。如果等于 0，并且类型元素是泛型，则返回该类型元素的原始类型。

如果返回一个参数化类型，则其类型元素不得包含在一般外部类中。例如，首先使用此方法获取类型 Outer<String>，然后调用 getDeclaredType(DeclaredType, TypeElement, TypeMirror...)，可以构造参数化类型 Outer<String>.Inner<Number>。

参数：
typeElem - 类型元素
typeArgs - 实际类型参数
返回：
对应于类型元素和实际类型参数的类型
抛出：
IllegalArgumentException - 如果给定的类型参数太多或太少，或者提供不合适的类型参数或类型元素

getDeclaredType

DeclaredType getDeclaredType(DeclaredType containing,
                             TypeElement typeElem,
                             TypeMirror... typeArgs)
根据给定的 包含类型，返回对应于类型元素和实际类型参数的类型（它是给定包含类型的成员）。例如，通过首先使用 getDeclaredType(TypeElement, TypeMirror...) 获取类型 Outer<String>，然后调用此方法，可以构造参数化类型 Outer<String>.Inner<Number>。

如果包含类型是一个参数化类型，则类型参数的数量必须等于 typeElem 的形式类型参数的数量。如果包含类型不是参数化的，或者为 null，则此方法等效于 getDeclaredType(typeElem, typeArgs)。

参数：
containing - 包含类型；如果没有，则该参数为 null
typeElem - 类型元素
typeArgs - 实际类型参数
返回：
对应于类型元素和实际类型参数的类型，该类型包含在给定类型中
抛出：
IllegalArgumentException - 如果给定的类型参数太多或太少，或者提供了不合适的类型参数、类型元素或包含类型

asMemberOf

TypeMirror asMemberOf(DeclaredType containing,
                      Element element)
当元素被视为给定类型的成员或者直接由给定类型包含时，返回该元素的类型。例如，被视为参数化类型 Set<String> 的成员时， Set.add 方法是参数类型为 String 的 ExecutableType。

参数：
containing - 包含类型
element - 元素
返回：
从包含类型来看的元素的类型
抛出：
IllegalArgumentException - 如果元素对于给定类型无效