Module  jdk.compiler
软件包  com.sun.source.util

Class TreeScanner<R,P>

  • 参数类型
    R - 这个访问者的方法的返回类型。 对不需要返回结果的访问者使用Void 。
    P - 访问者方法的附加参数的类型。 对不需要附加参数的访问者使用Void 。
    All Implemented Interfaces:
    TreeVisitor<R,P>
    已知直接子类：
    TreePathScanner 

    public class TreeScanner<R,P>
extends Object
implements TreeVisitor<R,P>
    访问所有子树节点的TreeVisitor。 要访问特定类型的节点，只需覆盖相应的visitXYZ方法即可。 在你的方法中，调用super.visitXYZ来访问后代节点。

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

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

    以下是一个树中标识符节点数量的示例： 

      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);
      }
   }
    从以下版本开始：
    1.6

    • 构造方法详细信息

      • TreeScanner

        public TreeScanner​()

    • 方法详细信息

      • scan

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

      • scan

        public R scan​(Iterable<? extends 树> 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节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitCompilationUnit在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitPackage

        public R visitPackage​(PackageTree node,
                      P p)
        访问PackageTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitPackage在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitImport

        public R visitImport​(ImportTree node,
                     P p)
        访问ImportTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitImport在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitClass

        public R visitClass​(ClassTree node,
                    P p)
        访问ClassTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitClass在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitMethod

        public R visitMethod​(MethodTree node,
                     P p)
        访问MethodTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitMethod在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitVariable

        public R visitVariable​(VariableTree node,
                       P p)
        访问VariableTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitVariable接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitEmptyStatement

        public R visitEmptyStatement​(EmptyStatementTree node,
                             P p)
        访问一个EmptyStatementTree节点。 此实现返回null 。
        Specified by:
        visitEmptyStatement在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 一个参数值
        结果
        扫描的结果

      • visitBlock

        public R visitBlock​(BlockTree node,
                    P p)
        访问BlockTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitBlock在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitDoWhileLoop

        public R visitDoWhileLoop​(DoWhileLoopTree node,
                          P p)
        访问DoWhileTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitDoWhileLoop在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitWhileLoop

        public R visitWhileLoop​(WhileLoopTree node,
                        P p)
        访问WhileLoopTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitWhileLoop在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 一个参数值
        结果
        扫描的结果

      • visitForLoop

        public R visitForLoop​(ForLoopTree node,
                      P p)
        访问ForLoopTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitForLoop在接口 TreeVisitor<R,P>
        参数
        node - 正在被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitEnhancedForLoop

        public R visitEnhancedForLoop​(EnhancedForLoopTree node,
                              P p)
        访问EnhancedForLoopTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitEnhancedForLoop在接口 TreeVisitor<R,P>
        参数
        node - 正在被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitLabeledStatement

        public R visitLabeledStatement​(LabeledStatementTree node,
                               P p)
        访问LabeledStatementTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitLabeledStatement接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitSwitch

        public R visitSwitch​(SwitchTree node,
                     P p)
        访问SwitchTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitSwitch在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitCase

        public R visitCase​(CaseTree node,
                   P p)
        访问CaseTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitCase在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitSynchronized

        public R visitSynchronized​(SynchronizedTree node,
                           P p)
        访问SynchronizedTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitSynchronized在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitTry

        public R visitTry​(TryTree node,
                  P p)
        访问TryTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitTry在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitCatch

        public R visitCatch​(CatchTree node,
                    P p)
        访问CatchTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitCatch在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitConditionalExpression

        public R visitConditionalExpression​(ConditionalExpressionTree node,
                                    P p)
        访问一个ConditionalExpressionTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitConditionalExpression在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitIf

        public R visitIf​(IfTree node,
                 P p)
        访问IfTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitIf在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitExpressionStatement

        public R visitExpressionStatement​(ExpressionStatementTree node,
                                  P p)
        访问ExpressionStatementTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitExpressionStatement在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitBreak

        public R visitBreak​(BreakTree node,
                    P p)
        访问BreakTree节点。 此实现返回null 。
        Specified by:
        visitBreak在接口 TreeVisitor<R,P>
        参数
        node - 正在被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitContinue

        public R visitContinue​(ContinueTree node,
                       P p)
        访问ContinueTree节点。 此实现返回null 。
        Specified by:
        visitContinue在接口 TreeVisitor<R,P>
        参数
        node - 正在被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitReturn

        public R visitReturn​(ReturnTree node,
                     P p)
        访问ReturnTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitReturn在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitThrow

        public R visitThrow​(ThrowTree node,
                    P p)
        访问ThrowTree节点 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitThrow在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitAssert

        public R visitAssert​(AssertTree node,
                     P p)
        访问AssertTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitAssert在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitMethodInvocation

        public R visitMethodInvocation​(MethodInvocationTree node,
                               P p)
        访问MethodInvocationTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitMethodInvocation在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitNewClass

        public R visitNewClass​(NewClassTree node,
                       P p)
        访问NewClassTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitNewClass在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitNewArray

        public R visitNewArray​(NewArrayTree node,
                       P p)
        访问NewArrayTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitNewArray在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitLambdaExpression

        public R visitLambdaExpression​(LambdaExpressionTree node,
                               P p)
        访问LambdaExpressionTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitLambdaExpression在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitParenthesized

        public R visitParenthesized​(ParenthesizedTree node,
                            P p)
        访问ParenthesizedTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitParenthesized在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitAssignment

        public R visitAssignment​(AssignmentTree node,
                         P p)
        访问AssignmentTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitAssignment在接口 TreeVisitor<R,P>
        参数
        node - 正在被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitCompoundAssignment

        public R visitCompoundAssignment​(CompoundAssignmentTree node,
                                 P p)
        访问一个CompoundAssignmentTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitCompoundAssignment在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitUnary

        public R visitUnary​(UnaryTree node,
                    P p)
        访问UnaryTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitUnary在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitBinary

        public R visitBinary​(BinaryTree node,
                     P p)
        访问二进制流节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitBinary在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitTypeCast

        public R visitTypeCast​(TypeCastTree node,
                       P p)
        访问TypeCastTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitTypeCast在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 一个参数值
        结果
        扫描的结果

      • visitInstanceOf

        public R visitInstanceOf​(InstanceOfTree node,
                         P p)
        访问InstanceOfTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitInstanceOf在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitArrayAccess

        public R visitArrayAccess​(ArrayAccessTree node,
                          P p)
        访问ArrayAccessTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitArrayAccess在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitMemberSelect

        public R visitMemberSelect​(MemberSelectTree node,
                           P p)
        访问MemberSelectTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitMemberSelect在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitMemberReference

        public R visitMemberReference​(MemberReferenceTree node,
                              P p)
        访问MemberReferenceTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitMemberReference在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitIdentifier

        public R visitIdentifier​(IdentifierTree node,
                         P p)
        访问IdentifierTree节点。 此实现返回null 。
        Specified by:
        visitIdentifier在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitLiteral

        public R visitLiteral​(LiteralTree node,
                      P p)
        访问LiteralTree节点。 此实现返回null 。
        Specified by:
        visitLiteral在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitPrimitiveType

        public R visitPrimitiveType​(PrimitiveTypeTree node,
                            P p)
        访问PrimitiveTypeTree节点。 此实现返回null 。
        Specified by:
        visitPrimitiveType在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitArrayType

        public R visitArrayType​(ArrayTypeTree node,
                        P p)
        访问ArrayTypeTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitArrayType在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitParameterizedType

        public R visitParameterizedType​(ParameterizedTypeTree node,
                                P p)
        访问ParameterizedTypeTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitParameterizedType在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitUnionType

        public R visitUnionType​(UnionTypeTree node,
                        P p)
        访问UnionTypeTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitUnionType在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitIntersectionType

        public R visitIntersectionType​(IntersectionTypeTree node,
                               P p)
        访问一个IntersectionTypeTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitIntersectionType在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 一个参数值
        结果
        扫描的结果

      • visitTypeParameter

        public R visitTypeParameter​(TypeParameterTree node,
                            P p)
        访问TypeParameterTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitTypeParameter在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitWildcard

        public R visitWildcard​(WildcardTree node,
                       P p)
        访问WildcardTypeTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitWildcard在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitModifiers

        public R visitModifiers​(ModifiersTree node,
                        P p)
        访问修饰符Tree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitModifiers在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitAnnotation

        public R visitAnnotation​(AnnotationTree node,
                         P p)
        访问AnnotatedTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitAnnotation在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 一个参数值
        结果
        扫描的结果

      • visitAnnotatedType

        public R visitAnnotatedType​(AnnotatedTypeTree node,
                            P p)
        访问AnnotatedTypeTree节点。 这个实现以从左到右的顺序扫描孩子。
        Specified by:
        visitAnnotatedType在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitModule

        public R visitModule​(ModuleTree node,
                     P p)
        描述从接口TreeVisitor复制
        访问ModuleTree节点。
        Specified by:
        visitModule在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        结果值

      • visitOpens

        public R visitOpens​(OpensTree node,
                    P p)
        说明从接口TreeVisitor复制
        访问OpensTree节点。
        Specified by:
        visitOpens在接口 TreeVisitor<R,P>
        参数
        node - 正在被访问的节点
        p - 参数值
        结果
        结果值

      • visitUses

        public R visitUses​(UsesTree node,
                   P p)
        描述从接口TreeVisitor复制
        访问UsesTree节点。
        Specified by:
        visitUses在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        结果值

      • visitOther

        public R visitOther​(树 node,
                    P p)
        访问未知类型的树节点。 如果语言演变，并且将新类型的节点添加到树层次结构中，则可能会发生这种情况。 此实现返回null 。
        Specified by:
        visitOther在接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果

      • visitErroneous

        public R visitErroneous​(ErroneousTree node,
                        P p)
        访问ErroneousTree节点。 此实现返回null 。
        Specified by:
        visitErroneous接口 TreeVisitor<R,P>
        参数
        node - 被访问的节点
        p - 参数值
        结果
        扫描的结果