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

Class TreeScanner<R,​P>

  • 参数类型
    R - 此访问者方法的返回类型。 对于不需要返回结果的访问者，请使用Void 。
    P - 此访问者方法的附加参数的类型。 对于不需要其他参数的访问者，请使用Void 。
    实现的所有接口
    TreeVisitor<R,​P>
    已知直接子类：
    TreePathScanner 
    public class TreeScanner<R,​P>extends Objectimplements TreeVisitor<R,​P>
    访问所有子树节点的TreeVisitor。 要访问特定类型的节点，只需覆盖相应的visitXYZ方法。 在您的方法中，调用super.visitXYZ来访问后代节点。

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

    • 如果被访问的节点没有子节点，则结果为null 。
    • 如果被访问的节点有一个子节点，则结果将是对该子节点调用scan的结果。 子节点可以是简单节点，也可以是节点列表。
    • 如果被访问的节点具有多个子节点，则将通过依次调用每个子scan来确定结果，然后将第一个之后的每个扫描的结果与迄今为止的累积结果组合，如reduce(R, R)方法所确定。 每个子节点可以是节点列表的简单节点。 reduce方法的默认行为是，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);      }   }
    从以下版本开始：
    1.6

    • 构造方法详细信息

      • TreeScanner

        public TreeScanner()

    • 方法详细信息

      • scan

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

      • 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)
        访问BinaryTree节点。 此实现按从左到右的顺序扫描子项。
        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)
        访问ModifiersTree节点。 此实现按从左到右的顺序扫描子项。
        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 - 参数值
        结果
        扫描的结果

      • visitOther

        public R visitOther​(树 node,                    P p)
        访问未知类型的Tree节点。 如果语言发展并且将新类型的节点添加到树层次结构中，则会发生这种情况。 此实现返回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 - 参数值
        结果
        扫描的结果