模块 java.compiler
包 javax.lang.model.util

接口 Elements

public interface Elements
对程序元素进行操作的实用方法。

兼容性说明：在平台的未来版本中，可能会将方法添加到此接口。

自从：
1.6
参见：

  • 方法详情

    • getPackageElement

      PackageElement  getPackageElement(CharSequence  name)
      如果包在环境中是唯一可确定的，则返回给定其完全限定名称的包。如果使用模块运行，则在两个阶段的过程中搜索给定名称的包： 如果此过程导致列表具有单个元素，则返回单个元素，否则返回 null。
      参数：
      name - 完全限定的包名称，或未命名包的空字符串
      返回：
      指定的包，或者 null 如果没有可以唯一确定的包。

    • getPackageElement

      default PackageElement  getPackageElement(ModuleElement  module, CharSequence  name)
      返回一个给定其完全限定名称的包，如从给定模块中看到的那样。
      实现要求：
      此方法的默认实现返回 null 。
      参数：
      module - 查找应该发生的相对模块
      name - 完全限定的包名称，或未命名包的空字符串
      返回：
      指定的包，如果找不到则返回 null
      自从：
      9
      参见：

    • getAllPackageElements

      default Set <? extends PackageElement > getAllPackageElements(CharSequence  name)
      返回具有给定规范名称的所有包元素。如果包元素位于不同的模块中，则可能存在多个具有相同规范名称的包元素。
      实现要求：
      此方法的默认实现调用 getAllModuleElements 并存储结果。如果模块集为空，则通过名称参数调用getPackageElement(name) 。如果 getPackageElement(name) 是 null ，则返回一组空的包元素；否则，返回包含找到的包元素的单元素集。如果模块集非空，则迭代模块并将 getPackageElement(module, name) 的任何非 null 结果累积到一个集合中。然后返回该集合。
      参数：
      name - 规范名称
      返回：
      包元素，如果找不到具有名称的包，则为空集
      自从：
      9
      参见：

    • getTypeElement

      TypeElement  getTypeElement(CharSequence  name)
      如果类型元素在环境中是唯一可确定的，则返回给定其规范名称的类型元素。如果使用模块运行，则在两阶段过程中搜索给定名称的类型元素： 如果此过程导致列表具有单个元素，则返回单个元素，否则返回 null。
      参数：
      name - 规范名称
      返回：
      命名的类型元素，或者 null 如果没有可以唯一确定的类型元素。

    • getTypeElement

      default TypeElement  getTypeElement(ModuleElement  module, CharSequence  name)
      返回给定其规范名称的类型元素，如从给定模块中看到的那样。
      实现要求：
      此方法的默认实现返回 null 。
      参数：
      module - 查找应该发生的相对模块
      name - 规范名称
      返回：
      命名的类型元素，如果找不到则返回 null
      自从：
      9
      参见：

    • getAllTypeElements

      default Set <? extends TypeElement > getAllTypeElements(CharSequence  name)
      返回具有给定规范名称的所有类型元素。如果类型元素位于不同的模块中，则可能存在多个具有相同规范名称的类型元素。
      实现要求：
      此方法的默认实现调用 getAllModuleElements 并存储结果。如果模块集为空，则通过名称参数调用getTypeElement(name) 。如果 getTypeElement(name) 是 null ，则返回一个空的类型元素集；否则，返回具有找到的类型元素的单元素集。如果模块集非空，则迭代模块并将 getTypeElement(module, name) 的任何非 null 结果累积到一个集合中。然后返回该集合。
      参数：
      name - 规范名称
      返回：
      类型元素，如果找不到具有名称的类型，则为空集
      自从：
      9
      参见：

    • getModuleElement

      default ModuleElement  getModuleElement(CharSequence  name)
      返回给定其完全限定名称的模块元素。如果找不到请求的模块，则返回 null。找不到模块的一种情况是环境不包含模块，例如为没有模块的源版本配置的注释处理环境。
      实现要求：
      此方法的默认实现返回 null 。
      参数：
      name - 未命名模块的名称或空字符串
      返回：
      命名的模块元素，或者 null 如果找不到
      自从：
      9
      参见：

    • getAllModuleElements

      default Set <? extends ModuleElement > getAllModuleElements()
      返回当前环境中的所有模块元素。如果不存在任何模块，则返回一个空集。当环境不包含模块时，会出现一种不存在模块的情况，例如为没有模块的源版本配置的注释处理环境。
      实现要求：
      此方法的默认实现返回一个空集。
      返回：
      已知的模块元素，如果没有模块则为空集
      自从：
      9
      参见：

    • getElementValuesWithDefaults

      Map <? extends ExecutableElement ,? extends AnnotationValue > getElementValuesWithDefaults(AnnotationMirror  a)
      返回注解元素的值，包括默认值。
      参数：
      a - 要检查的注释
      返回：
      注解元素的值，包括默认值
      参见：

    • getDocComment

      String  getDocComment(Element  e)
      返回元素的文档（“Javadoc”）注释的文本。

      元素的文档注释是以“/**”开头，以单独的“*/”结尾，紧接在元素之前的注释，忽略空格。因此，文档注释至少包含三个“*”字符。为文档注释返回的文本是源代码中出现的注释的处理形式。删除前导“/**”和尾随“*/”。对于在初始“/**”之后开始的注释行，前导空白字符将被丢弃，因为出现在空白之后或开始该行的任何连续“*”字符也是如此。然后将处理后的行连接在一起（包括行终止符）并返回。

      参数：
      e - 正在检查的元素
      返回：
      元素的文档注释，如果没有则为 null
      看Java 语言规范:
      3.6 空白

    • isDeprecated

      boolean isDeprecated(Element  e)
      如果该元素已弃用，则返回 true，否则返回 false。
      参数：
      e - 正在检查的元素
      返回：
      true 如果该元素已弃用，false 否则

    • getOrigin

      default Elements.Origin  getOrigin(Element  e)
      返回给定元素的 origin。

      请注意，如果此方法返回 EXPLICIT 并且该元素是从类文件创建的，那么该元素实际上可能不对应于源代码中显式声明的构造。这是由于类文件格式在保留源代码信息方面的保真度的限制。例如，至少某些版本的类文件格式不保留构造函数是由程序员显式声明还是隐式声明为 default constructor 。

      实现要求：
      此方法的默认实现返回 EXPLICIT 。
      参数：
      e - 正在检查的元素
      返回：
      给定元素的 origin
      自从：
      9

    • getOrigin

      default Elements.Origin  getOrigin(AnnotatedConstruct  c, AnnotationMirror  a)
      返回给定注释镜像的origin。注释镜像是强制的，如果它是隐式声明的container annotation，用于保存可重复注释接口的重复注释。

      请注意，如果此方法返回 EXPLICIT 并且注释镜像是从类文件创建的，那么该元素实际上可能不对应于源代码中显式声明的构造。这是由于类文件格式在保留源代码信息方面的保真度的限制。例如，至少某些版本的类文件格式不保留注释是由程序员显式声明还是隐式声明为 container annotation 。

      实现要求：
      此方法的默认实现返回 EXPLICIT 。
      参数：
      c - 注释镜像修改的构造
      a - 正在检查的注释镜像
      返回：
      给定注释镜像的origin
      看Java 语言规范:
      9.6.3 可重复的注解接口
      9.7.5 同一接口的多个注解
      自从：
      9

    • getOrigin

      default Elements.Origin  getOrigin(ModuleElement  m, ModuleElement.Directive  directive)
      返回给定模块指令的 origin。

      请注意，如果此方法返回 EXPLICIT 并且模块指令是从类文件创建的，那么模块指令实际上可能不对应于源代码中显式声明的构造。这是由于类文件格式在保留源代码信息方面的保真度的限制。例如，至少某些版本的类文件格式不保留 uses 指令是由程序员显式声明还是作为合成构造添加的。

      请注意，如果指令是从类文件创建的，则实现可能无法可靠地确定指令的原始状态，因为类文件格式在保留源代码信息方面的保真度受到限制。

      实现要求：
      此方法的默认实现返回 EXPLICIT 。
      参数：
      m - 指令的模块
      directive - 正在检查的模块指令
      返回：
      给定模块指令的 origin
      自从：
      9

    • isBridge

      default boolean isBridge(ExecutableElement  e)
      如果可执行元素是桥接方法，则返回 true，否则返回 false。
      实现要求：
      此方法的默认实现返回 false 。
      参数：
      e - 正在检查的可执行文件
      返回：
      true 如果可执行元素是桥接方法，false 否则
      自从：
      9

    • getBinaryName

      Name  getBinaryName(TypeElement  type)
      返回二进制名称类型元素。
      参数：
      type - 正在检查的类型元素
      返回：
      这二进制名称类型元素
      看Java 语言规范:
      13.1 二进制形式
      参见：

    • getPackageOf

      PackageElement  getPackageOf(Element  e)
      返回元素的包。一个包的包就是它自己。一个模块的包是null。顶级类或接口的包是它的 外包装 。否则，元素的封装等于 封闭元素 的封装。
      参数：
      e - 正在检查的元素
      返回：
      元素的封装

    • getModuleOf

      default ModuleElement  getModuleOf(Element  e)
      返回元素的模块。模块的模块就是它自己。如果一个包有一个模块作为它的 封闭元素 ，那个模块就是包的模块。如果包的封闭元素是 null ，则包的模块返回 null。 （一个包可能有null模块的一种情况是如果环境不包含模块，例如为没有模块的源版本配置的注解处理环境。）否则，一个元素的模块等于该元素的模块包 .
      实现要求：
      此方法的默认实现返回 null 。
      参数：
      e - 正在检查的元素
      返回：
      元素的模块
      自从：
      9

    • getAllMembers

      List <? extends Element > getAllMembers(TypeElement  type)
      返回类型元素的所有成员，无论是继承的还是直接声明的。对于一个类，结果还包括它的构造方法，但不包括本地类或匿名类。
      API 注意：
      可以使用 ElementFilter 中的方法隔离某些种类的元素。
      参数：
      type - 正在检查的类型
      返回：
      该类型的所有成员
      参见：

    • getOutermostTypeElement

      default TypeElement  getOutermostTypeElement(Element  e)
      如果存在这样的包含元素，则返回包含该元素的最外层类型元素；否则返回 null 。 模块 和 packages do not 具有包含类型元素，因此为这些类型的元素返回 null。 顶层 类或接口是它自己的最外层类型元素。
      实现要求：
      此方法的默认实现首先检查参数的类型。对于种类为 PACKAGE、 MODULE 和 OTHER 的元素，返回 null。对于其他类型的元素，将检查该元素以查看它是否是顶级类或接口。如果是，则返回该元素；否则，将遵循 封闭元素 链，直到找到顶级类或接口。返回最终顶级类或接口的元素。
      参数：
      e - 正在检查的元素
      返回：
      如果存在这样的包含元素，则元素包含在最外层类型元素中；否则返回 null
      自从：
      18
      参见：

    • getAllAnnotationMirrors

      List <? extends AnnotationMirror > getAllAnnotationMirrors(Element  e)
      返回所有注释展示在元素上，无论是直接存在还是通过继承存在。

      请注意，此方法返回的任何注释都是声明注解。

      参数：
      e - 正在检查的元素
      返回：
      元素的所有注释
      参见：

    • hides

      boolean hides(Element  hider, Element  hidden)
      测试一种类型、方法或字段是否隐藏了另一种类型、方法或字段。
      参数：
      hider - 第一个元素
      hidden - 第二个元素
      返回：
      true 当且仅当第一个元素隐藏第二个时
      看Java 语言规范:
      8.4.8 继承、覆盖和隐藏

    • overrides

      boolean overrides(ExecutableElement  overrider, ExecutableElement  overridden, TypeElement  type)
      测试一个方法是否作为给定类或接口的成员重写另一个方法。当一个非抽象方法重写一个抽象方法时，前者也被称为实施后者。正如 JLS 8.4.8.1 所暗示的，方法确实 not 覆盖了自身。覆盖关系是反身的.

      在最简单和最典型的用法中，type 参数的值将只是直接包含 overrider（可能覆盖的方法）的类或接口。例如，假设 m1 代表方法 String.hashCode 并且 m2 代表 Object.hashCode 。然后我们可以询问 m1 是否覆盖了类 String 中的 m2（确实如此）：

      assert elements.overrides(m1, m2, elements.getTypeElement("java.lang.String"));
      下面的示例可以说明一个更有趣的情况，其中类 A 中的方法不会覆盖接口 B 中的同名方法：
      class A { public void m() {} }
      interface B { void m(); }
      ...
      m1 = ...; // A.m
      m2 = ...; // B.m
      assert ! elements.overrides(m1, m2, elements.getTypeElement("A"));
      然而，当被视为第三类 C 的成员时， A 中的方法确实覆盖了 B 中的方法：
      class C extends A implements B {}
      ...
      assert elements.overrides(m1, m2, elements.getTypeElement("C"));
      参数：
      overrider - 第一种方法，可能的覆盖
      overridden - 第二种方法，可能被覆盖
      type - 第一个方法所属的类或接口
      返回：
      true 当且仅当第一个方法覆盖第二个
      看Java 语言规范:
      8.4.8 继承、覆盖和隐藏
      9.4.1 继承与覆盖

    • getConstantExpression

      String  getConstantExpression(Object  value)
      返回 a 的文本常量表达式表示原始值或字符串。返回的文本采用适合表示源代码中的值的形式。
      参数：
      value - 原始值或字符串
      返回：
      常量表达式的文本
      抛出：
      IllegalArgumentException - 如果参数不是原始值或字符串
      参见：

    • printElements

      void printElements(Writer  w, Element ... elements)
      按指定顺序将元素的表示形式打印到给定的编写器。该方法的主要目的是用于诊断。输出的确切格式是 not 指定的，并且可能会发生变化。
      参数：
      w - 将输出打印到的编写器
      elements - 要打印的元素

    • getName

      Name  getName(CharSequence  cs)
      返回与参数具有相同字符序列的名称。
      参数：
      cs - 作为名称返回的字符序列
      返回：
      与参数具有相同字符序列的名称

    • isFunctionalInterface

      boolean isFunctionalInterface(TypeElement  type)
      如果类型元素是功能接口，则返回 true，否则返回 false。
      参数：
      type - 正在检查的类型元素
      返回：
      true 如果类型元素是功能接口，false 否则
      看Java 语言规范:
      9.8 功能接口
      自从：
      1.8

    • isAutomaticModule

      default boolean isAutomaticModule(ModuleElement  module)
      如果模块元素是自动模块，则返回 true，否则返回 false。
      实现要求：
      此方法的默认实现返回 false 。
      参数：
      module - 正在检查的模块元素
      返回：
      true 如果模块元素是一个自动模块，false 否则
      看Java 语言规范:
      7.7.1 依赖关系
      自从：
      17

    • recordComponentFor

      default RecordComponentElement  recordComponentFor(ExecutableElement  accessor)
      返回给定访问器的记录组件。如果给定方法不是记录组件访问器，则返回 null。
      实现要求：
      此方法的默认实现检查包含访问器的元素是否具有种类 RECORD 如果是这种情况，则通过调用 ElementFilter.recordComponentsIn(Iterable) 检索访问器包含元素上的所有记录组件。如果检索到的至少一个记录组件的访问器恰好等于作为参数传递给此方法的访问器，则返回该记录组件，在任何其他情况下返回 null。
      参数：
      accessor - 应为其找到记录组件的方法。
      返回：
      记录组件，或者 null 如果给定方法不是记录组件访问器
      自从：
      16

    • isCanonicalConstructor

      default boolean isCanonicalConstructor(ExecutableElement  e)
      如果可以确定可执行元素是记录的规范构造函数，则返回 true，否则返回 false。请注意，在某些情况下，可能没有足够的信息来确定构造函数是否是规范构造函数，例如可执行元素是否由类文件构建。在这种情况下，返回 false。
      实现要求：
      此方法的默认实现无条件返回 false 。
      参数：
      e - 正在检查的可执行文件
      返回：
      true 如果可以确定可执行元素是记录的规范构造函数， false 否则
      看Java 语言规范:
      8.10.4.1 正常规范构造函数
      自从：
      20

    • isCompactConstructor

      default boolean isCompactConstructor(ExecutableElement  e)
      如果可以确定可执行元素是记录的紧凑构造函数，则返回 true，否则返回 false。根据定义，紧凑构造函数也是 规范构造器 。请注意，在某些情况下，可能没有足够的信息来确定构造函数是否为紧凑构造函数，例如可执行元素是否由类文件构建。在这种情况下，返回 false。
      实现要求：
      此方法的默认实现无条件返回 false 。
      参数：
      e - 正在检查的可执行文件
      返回：
      true 如果可以确定可执行元素是记录的紧凑构造函数， false 否则
      看Java 语言规范:
      8.10.4.2 紧凑规范构造函数
      自从：
      20

    • getFileObjectOf

      default JavaFileObject  getFileObjectOf(Element  e)
      返回此元素的文件对象，如果没有这样的文件对象，则返回 null。

      返回的文件对象是用于构造元素的信息的参考表示。例如，如果在编译或注释处理期间，类 Foo 的源文件被编译成类文件，则为表示 Foo 的元素返回的文件对象将用于源文件，not 用于类文件。

      实现可以选择不支持此方法的功能，在这种情况下会抛出 UnsupportedOperationException 。

      在注释处理的上下文中，如果元素作为初始输入的一部分包含在内，或者包含文件是在注释处理工具运行期间创建的，则返回一个非null值。否则，可能会返回 null。在注释处理中，如果是 类文件被创建 ，则该类文件可以作为元素的引用表示。

      如果它有一个文件对象，则包的文件对象将是一个 package-info 文件。一个包可能存在并且没有任何 package-info 文件，即使该包是在注释处理运行期间（隐式地）创建的，从该包中的源文件或类文件的创建运行。 未命名包 将有一个 null 文件，因为它不能在编译单元中声明。

      如果它有一个文件对象，模块的文件对象将是一个module-info文件。 未命名模块 将有一个 null 文件，因为它不能在编译单元中声明。 自动模块 将有一个 null 文件，因为它是隐式声明的。

      如果它有文件对象，则顶级public类或接口的文件对象将是与该类或接口对应的源文件或类文件。在这种情况下，文件名的前导部分通常与类或接口的名称相匹配。单个编译单元可以定义多个顶级类和接口，例如名称与文件名对应的主要public类或接口以及名称与文件名不对应的一个或多个auxiliary类或接口。如果源文件提供辅助类或接口的引用表示，则返回主类的文件。 （辅助类或接口也可以在 package-info 源文件中定义，在这种情况下返回 package-info 文件的文件。）如果类文件提供辅助类或接口的引用表示，则单独的类文件用于返回辅助类。

      对于嵌套类或接口，如果它有一个文件对象：

      • 如果源文件提供引用表示，则文件对象将是最外层类或接口的对象
      • 如果类文件提供引用表示，则文件对象将是嵌套类或接口本身的对象

      对于其他词法封闭元素，如 variables 、 方法和构造函数 ，如果它们有文件对象，则文件对象将是与词法封闭元素的 封闭元素 关联的对象。

      实现要求：
      默认实现无条件抛出 UnsupportedOperationException 。
      参数：
      e - 为其查找文件对象的元素
      返回：
      此元素的文件对象或 null 如果没有这样的文件对象
      抛出：
      UnsupportedOperationException - 如果不支持此功能
      自从：
      18