模块 jdk.compiler
包 com.sun.source.util

类 TreeScanner<R,P>

java.lang.Object
com.sun.source.util.TreeScanner<R,P>
类型参数：
R - 此访问者方法的返回类型。对不需要返回结果的访问者使用Void 。
P - 此访问者方法的附加参数的类型。 Void 用于不需要额外参数的访问者。
所有已实现的接口：
TreeVisitor<R,P>
已知子类：
TreePathScanner
public class TreeScanner<R,P> extends Object implements TreeVisitor <R,P>
访问所有子树节点的 TreeVisitor。要访问特定类型的节点，只需重写相应的 visitXYZ 方法即可。在您的方法中，调用 super.visitXYZ 以访问后代节点。

这是一个计算树中标识符节点数的示例：

  class CountIdentifiers extends TreeScanner<Integer,Void> {
   @Override
   public Integer visitIdentifier(IdentifierTree node, Void p) {
     return 1;
   }
   @Override
   public Integer reduce(Integer r1, Integer r2) {
     return (r1 == null ? 0 : r1) + (r2 == null ? 0 : r2);
   }
  }
实现要求：

visitXYZ 方法的默认实现将确定如下结果：

  • 如果被访问的节点没有子节点，则结果将为 null 。
  • 如果被访问的节点有一个孩子，则结果将是对该孩子调用 scan 的结果。孩子可能是一个简单的节点或本身就是一个节点列表。
  • 如果被访问的节点有多个子节点，则结果将通过对每个子节点依次调用 scan 来确定，然后将第一次扫描后的每次扫描结果与到目前为止的累积结果相结合，由 reduce(R, R) 方法确定。每个子节点可以是一个简单节点或一个节点列表。 reduce 方法的默认行为是 visitXYZ 方法的结果将是最后一个孩子扫描的结果。
自从：
1.6

  • 构造方法详细信息

    • TreeScanner

      public TreeScanner()
      构造一个 TreeScanner

  • 方法详情

    • scan

      public R  scan(Tree  tree, P  p)
      扫描单个节点。
      参数：
      tree - 要扫描的节点
      p - 传递给访问方法的参数值
      返回：
      访问方法的结果值

    • scan

      public R  scan(Iterable <? extends Tree > nodes, P  p)
      扫描一系列节点。
      参数：
      nodes - 要扫描的节点
      p - 要传递给每个节点的访问方法的参数值
      返回：
      访问方法的组合返回值。使用 reduce 方法组合这些值。

    • reduce

      public R  reduce(R  r1, R  r2)
      将两个结果缩减为一个组合结果。默认实现是返回第一个参数。该方法的一般契约是它可以采取任何行动。
      参数：
      r1 - 要组合的第一个值
      r2 - 要组合的第二个值
      返回：
      结合两个参数的结果

    • visitCompilationUnit

      public R  visitCompilationUnit(CompilationUnitTree  node, P  p)
      访问 CompilationUnitTree 节点。
      指定者：
      visitCompilationUnit 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitPackage

      public R  visitPackage(PackageTree  node, P  p)
      访问 PackageTree 节点。
      指定者：
      visitPackage 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitImport

      public R  visitImport(ImportTree  node, P  p)
      访问 ImportTree 节点。
      指定者：
      visitImport 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitClass

      public R  visitClass(ClassTree  node, P  p)
      访问 ClassTree 节点。
      指定者：
      visitClass 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitMethod

      public R  visitMethod(MethodTree  node, P  p)
      访问 MethodTree 节点。
      指定者：
      visitMethod 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitVariable

      public R  visitVariable(VariableTree  node, P  p)
      访问 VariableTree 节点。
      指定者：
      visitVariable 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitEmptyStatement

      public R  visitEmptyStatement(EmptyStatementTree  node, P  p)
      访问 EmptyStatementTree 节点。
      指定者：
      visitEmptyStatement 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现返回 null 。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitBlock

      public R  visitBlock(BlockTree  node, P  p)
      访问 BlockTree 节点。
      指定者：
      visitBlock 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitDoWhileLoop

      public R  visitDoWhileLoop(DoWhileLoopTree  node, P  p)
      访问 DoWhileTree 节点。
      指定者：
      visitDoWhileLoop 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitWhileLoop

      public R  visitWhileLoop(WhileLoopTree  node, P  p)
      访问 WhileLoopTree 节点。
      指定者：
      visitWhileLoop 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitForLoop

      public R  visitForLoop(ForLoopTree  node, P  p)
      访问 ForLoopTree 节点。
      指定者：
      visitForLoop 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitEnhancedForLoop

      public R  visitEnhancedForLoop(EnhancedForLoopTree  node, P  p)
      访问 EnhancedForLoopTree 节点。
      指定者：
      visitEnhancedForLoop 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitLabeledStatement

      public R  visitLabeledStatement(LabeledStatementTree  node, P  p)
      访问 LabeledStatementTree 节点。
      指定者：
      visitLabeledStatement 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitSwitch

      public R  visitSwitch(SwitchTree  node, P  p)
      访问 SwitchTree 节点。
      指定者：
      visitSwitch 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitSwitchExpression

      public R  visitSwitchExpression(SwitchExpressionTree  node, P  p)
      访问 SwitchExpressionTree 节点。
      指定者：
      visitSwitchExpression 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitCase

      public R  visitCase(CaseTree  node, P  p)
      访问 CaseTree 节点。
      指定者：
      visitCase 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitSynchronized

      public R  visitSynchronized(SynchronizedTree  node, P  p)
      访问 SynchronizedTree 节点。
      指定者：
      visitSynchronized 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitTry

      public R  visitTry(TryTree  node, P  p)
      访问 TryTree 节点。
      指定者：
      visitTry 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitCatch

      public R  visitCatch(CatchTree  node, P  p)
      访问 CatchTree 节点。
      指定者：
      visitCatch 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitConditionalExpression

      public R  visitConditionalExpression(ConditionalExpressionTree  node, P  p)
      访问 ConditionalExpressionTree 节点。
      指定者：
      visitConditionalExpression 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitIf

      public R  visitIf(IfTree  node, P  p)
      访问 IfTree 节点。
      指定者：
      visitIf 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitExpressionStatement

      public R  visitExpressionStatement(ExpressionStatementTree  node, P  p)
      访问 ExpressionStatementTree 节点。
      指定者：
      visitExpressionStatement 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitBreak

      public R  visitBreak(BreakTree  node, P  p)
      访问 BreakTree 节点。
      指定者：
      visitBreak 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现返回 null 。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitContinue

      public R  visitContinue(ContinueTree  node, P  p)
      访问 ContinueTree 节点。
      指定者：
      visitContinue 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现返回 null 。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitReturn

      public R  visitReturn(ReturnTree  node, P  p)
      访问 ReturnTree 节点。
      指定者：
      visitReturn 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitThrow

      public R  visitThrow(ThrowTree  node, P  p)
      访问 ThrowTree 节点。
      指定者：
      visitThrow 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitAssert

      public R  visitAssert(AssertTree  node, P  p)
      访问 AssertTree 节点。
      指定者：
      visitAssert 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitMethodInvocation

      public R  visitMethodInvocation(MethodInvocationTree  node, P  p)
      访问 MethodInvocationTree 节点。
      指定者：
      visitMethodInvocation 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitNewClass

      public R  visitNewClass(NewClassTree  node, P  p)
      访问 NewClassTree 节点。
      指定者：
      visitNewClass 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitNewArray

      public R  visitNewArray(NewArrayTree  node, P  p)
      访问 NewArrayTree 节点。
      指定者：
      visitNewArray 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitLambdaExpression

      public R  visitLambdaExpression(LambdaExpressionTree  node, P  p)
      访问 LambdaExpressionTree 节点。
      指定者：
      visitLambdaExpression 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitParenthesized

      public R  visitParenthesized(ParenthesizedTree  node, P  p)
      访问 ParenthesizedTree 节点。
      指定者：
      visitParenthesized 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitAssignment

      public R  visitAssignment(AssignmentTree  node, P  p)
      访问 AssignmentTree 节点。
      指定者：
      visitAssignment 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitCompoundAssignment

      public R  visitCompoundAssignment(CompoundAssignmentTree  node, P  p)
      访问 CompoundAssignmentTree 节点。
      指定者：
      visitCompoundAssignment 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitUnary

      public R  visitUnary(UnaryTree  node, P  p)
      访问 UnaryTree 节点。
      指定者：
      visitUnary 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitBinary

      public R  visitBinary(BinaryTree  node, P  p)
      访问 BinaryTree 节点。
      指定者：
      visitBinary 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitTypeCast

      public R  visitTypeCast(TypeCastTree  node, P  p)
      访问 TypeCastTree 节点。
      指定者：
      visitTypeCast 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitInstanceOf

      public R  visitInstanceOf(InstanceOfTree  node, P  p)
      访问 InstanceOfTree 节点。
      指定者：
      visitInstanceOf 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitBindingPattern

      public R  visitBindingPattern(BindingPatternTree  node, P  p)
      访问 BindingPatternTree 节点。
      指定者：
      visitBindingPattern 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果
      自从：
      14

    • visitDefaultCaseLabel

      public R  visitDefaultCaseLabel(DefaultCaseLabelTree PREVIEW  node, P  p)
      visitDefaultCaseLabel是Java平台的反射预览API。
      预览功能可能会在未来的版本中删除，或升级为 Java 平台的永久功能。
      访问 DefaultCaseLabelTree 节点。
      指定者：
      visitDefaultCaseLabel 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现返回 null 。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果
      自从：
      17

    • visitConstantCaseLabel

      public R  visitConstantCaseLabel(ConstantCaseLabelTree PREVIEW  node, P  p)
      visitConstantCaseLabel是Java平台的反射预览API。
      预览功能可能会在未来的版本中删除，或升级为 Java 平台的永久功能。
      访问 ConstantCaseLabelTree 节点。
      指定者：
      visitConstantCaseLabel 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现返回 null 。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果
      自从：
      19

    • visitPatternCaseLabel

      public R  visitPatternCaseLabel(PatternCaseLabelTree PREVIEW  node, P  p)
      visitPatternCaseLabel是Java平台的反射预览API。
      预览功能可能会在未来的版本中删除，或升级为 Java 平台的永久功能。
      访问 PatternCaseLabelTree 节点。
      指定者：
      visitPatternCaseLabel 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现返回 null 。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果
      自从：
      19

    • visitDeconstructionPattern

      public R  visitDeconstructionPattern(DeconstructionPatternTree PREVIEW  node, P  p)
      visitDeconstructionPattern是Java平台的反射预览API。
      预览功能可能会在未来的版本中删除，或升级为 Java 平台的永久功能。
      访问 DeconstructionPatternTree 节点。
      指定者：
      visitDeconstructionPattern 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果
      自从：
      19

    • visitArrayAccess

      public R  visitArrayAccess(ArrayAccessTree  node, P  p)
      访问 ArrayAccessTree 节点。此实现按从左到右的顺序扫描子项。
      指定者：
      visitArrayAccess 在接口 TreeVisitor<R,P> 中
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitMemberSelect

      public R  visitMemberSelect(MemberSelectTree  node, P  p)
      访问 MemberSelectTree 节点。
      指定者：
      visitMemberSelect 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitParenthesizedPattern

      public R  visitParenthesizedPattern(ParenthesizedPatternTree PREVIEW  node, P  p)
      visitParenthesizedPattern是Java平台的反射预览API。
      预览功能可能会在未来的版本中删除，或升级为 Java 平台的永久功能。
      访问 ParenthesizedPatternTree 节点。
      指定者：
      visitParenthesizedPattern 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果
      自从：
      17

    • visitMemberReference

      public R  visitMemberReference(MemberReferenceTree  node, P  p)
      访问 MemberReferenceTree 节点。
      指定者：
      visitMemberReference 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitIdentifier

      public R  visitIdentifier(IdentifierTree  node, P  p)
      访问 IdentifierTree 节点。
      指定者：
      visitIdentifier 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现返回 null 。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitLiteral

      public R  visitLiteral(LiteralTree  node, P  p)
      访问 LiteralTree 节点。
      指定者：
      visitLiteral 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现返回 null 。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitPrimitiveType

      public R  visitPrimitiveType(PrimitiveTypeTree  node, P  p)
      访问 PrimitiveTypeTree 节点。
      指定者：
      visitPrimitiveType 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现返回 null 。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitArrayType

      public R  visitArrayType(ArrayTypeTree  node, P  p)
      访问 ArrayTypeTree 节点。
      指定者：
      visitArrayType 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitParameterizedType

      public R  visitParameterizedType(ParameterizedTypeTree  node, P  p)
      访问 ParameterizedTypeTree 节点。
      指定者：
      visitParameterizedType 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitUnionType

      public R  visitUnionType(UnionTypeTree  node, P  p)
      访问 UnionTypeTree 节点。
      指定者：
      visitUnionType 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitIntersectionType

      public R  visitIntersectionType(IntersectionTypeTree  node, P  p)
      访问 IntersectionTypeTree 节点。
      指定者：
      visitIntersectionType 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitTypeParameter

      public R  visitTypeParameter(TypeParameterTree  node, P  p)
      访问 TypeParameterTree 节点。
      指定者：
      visitTypeParameter 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitWildcard

      public R  visitWildcard(WildcardTree  node, P  p)
      访问 WildcardTypeTree 节点。
      指定者：
      visitWildcard 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitModifiers

      public R  visitModifiers(ModifiersTree  node, P  p)
      访问 ModifiersTree 节点。
      指定者：
      visitModifiers 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitAnnotation

      public R  visitAnnotation(AnnotationTree  node, P  p)
      访问 AnnotatedTree 节点。
      指定者：
      visitAnnotation 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitAnnotatedType

      public R  visitAnnotatedType(AnnotatedTypeTree  node, P  p)
      访问 AnnotatedTypeTree 节点。
      指定者：
      visitAnnotatedType 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitModule

      public R  visitModule(ModuleTree  node, P  p)
      访问 ModuleTree 节点。
      指定者：
      visitModule 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitExports

      public R  visitExports(ExportsTree  node, P  p)
      访问 ExportsTree 节点。
      指定者：
      visitExports 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitOpens

      public R  visitOpens(OpensTree  node, P  p)
      访问 OpensTree 节点。
      指定者：
      visitOpens 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitProvides

      public R  visitProvides(ProvidesTree  node, P  p)
      访问 ProvidesTree 节点。
      指定者：
      visitProvides 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitRequires

      public R  visitRequires(RequiresTree  node, P  p)
      访问 RequiresTree 节点。
      指定者：
      visitRequires 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitUses

      public R  visitUses(UsesTree  node, P  p)
      访问 UsesTree 节点。
      指定者：
      visitUses 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitOther

      public R  visitOther(Tree  node, P  p)
      访问未知类型的 Tree 节点。如果语言发展并且新类型的节点被添加到 Tree 层次结构中，就会发生这种情况。
      指定者：
      visitOther 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现返回 null 。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitErroneous

      public R  visitErroneous(ErroneousTree  node, P  p)
      访问 ErroneousTree 节点。
      指定者：
      visitErroneous 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现返回 null 。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果

    • visitYield

      public R  visitYield(YieldTree  node, P  p)
      访问 YieldTree 节点。
      指定者：
      visitYield 在接口 TreeVisitor<R,P> 中
      实现要求：
      此实现按从左到右的顺序扫描子项。
      参数：
      node - 被访问的节点
      p - 一个参数值
      返回：
      扫描结果