Module jdk.compiler
Package com.sun.source.util

Class 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>
TreeScanner 依赖于Java平台的预览功能:
仅当启用预览功能时，程序才能使用TreeScanner。
预览功能可能在将来的版本中被移除，或升级为Java平台的永久功能。
访问所有子树节点的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

  • Constructor Details

    • TreeScanner

      public TreeScanner()
      构造一个TreeScanner。

  • Method Details

    • 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 - 参数值
      返回：
      扫描结果

    • visitAnyPattern

      public R visitAnyPattern(AnyPatternTreePREVIEW node, P p)
      访问AnyPatternTree节点。
      指定者：
      visitAnyPattern 在接口 TreeVisitor<R,P>
      实现要求：
      此实现返回null。
      参数：
      node - 正在访问的节点
      p - 参数值
      返回：
      扫描结果
      自：
      21

    • visitStringTemplate

      public R visitStringTemplate(StringTemplateTreePREVIEW node, P p)
      visitStringTemplate是Java平台的反射预览API。
      预览功能可能会在将来的版本中被移除，或升级为Java平台的永久功能。
      访问StringTemplateTree节点。
      指定者：
      visitStringTemplate 在接口 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 node, P p)
      访问DefaultCaseLabelTree节点。
      指定者：
      visitDefaultCaseLabel 在接口 TreeVisitor<R,P>
      实现要求：
      此实现返回null。
      参数：
      node - 正在访问的节点
      p - 参数值
      返回：
      扫描结果
      自：
      21

    • visitConstantCaseLabel

      public R visitConstantCaseLabel(ConstantCaseLabelTree node, P p)
      访问ConstantCaseLabelTree节点。
      指定由：
      visitConstantCaseLabel 在接口 TreeVisitor<R,P>
      实现要求：
      此实现返回null。
      参数：
      node - 正在访问的节点
      p - 参数值
      返回：
      扫描结果
      自：
      21

    • visitPatternCaseLabel

      public R visitPatternCaseLabel(PatternCaseLabelTree node, P p)
      访问PatternCaseLabelTree节点。
      指定由：
      visitPatternCaseLabel 在接口 TreeVisitor<R,P>
      实现要求：
      此实现返回null。
      参数：
      node - 正在访问的节点
      p - 参数值
      返回：
      扫描结果
      自：
      21

    • visitDeconstructionPattern

      public R visitDeconstructionPattern(DeconstructionPatternTree node, P p)
      访问DeconstructionPatternTree节点。
      指定由：
      visitDeconstructionPattern 在接口 TreeVisitor<R,P>
      实现要求：
      此实现按从左到右的顺序扫描子节点。
      参数：
      node - 正在访问的节点
      p - 参数值
      返回：
      扫描结果
      自：
      21

    • 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 - 参数值
      返回：
      扫描结果

    • 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 - 一个参数值
      返回值:
      扫描结果