Class SwitchEntry

java.lang.Object
com.github.javaparser.ast.Node
com.github.javaparser.ast.stmt.SwitchEntry
All Implemented Interfaces:
NodeWithRange<Node>, NodeWithStatements<SwitchEntry>, NodeWithTokenRange<Node>, Observable, Visitable, HasParentNode<Node>, Cloneable
public class SwitchEntry extends Node implements NodeWithStatements<SwitchEntry>

One case in a switch statement

The main Javadoc is in SwitchStmt

Java 1.0-11

switch (i) {
  case 1:
  case 2:
    System.out.println(444);
    break;
  default:
    System.out.println(0);
}

This contains three SwitchEntrys. All of them are of type STATEMENT_GROUP.
  • The first one has label 1 and no statements.
  • The second has label 2 and two statements (the println and the break).
  • The third, the default, has no label and one statement.

Java 12-

    case 1 -> 15*15;
    case 2 -> { a++; b++; }
    case 3 -> throw new Exception();
These are three new variants.
  • The first one is of type EXPRESSION and stores its Expression in an ExpressionStmt which is stored as the first and only statement in statements.
  • The second one is of type BLOCK and stores its BlockStmt as the first and only statement in statements.
  • The third one is of type THROWS_STATEMENT and stores its ThrowStmt as the first and only statement in statements.
    case MONDAY, FRIDAY, SUNDAY -> 6;
Multiple case labels are now allowed. 
    case 16*16, 10+10 -> 6;
Many kinds of expressions are now allowed. Note (https://github.com/javaparser/javaparser/pull/4679): The JavaParser representation for SwitchEntry is (slightly) incorrect. JP Assumes that the body of a SwitchEntry will be a list of statements which was true before switch expressions were added, but is no longer the case for this rule. The workaround for this was to wrap the expression in an ExpressionStmt node which works well, but is not entirely correct according to the JLS since the ExpressionStmt in this specific case can contain any expression, not just those which are legal expression statements according to the JLS, for example below (a lambda is not a valid expression statement, but the below snippet is still legal Java code): 
     return switch (o) {
         case String s -> (arg) -> System.out.println(arg + s);
         case null, default -> (arg) -> {};
     };
https://docs.oracle.com/javase/specs/jls/se21/html/jls-15.html#jls-15.28 https://docs.oracle.com/javase/specs/jls/se21/html/jls-14.html#jls-14.8
Author:
Julio Vilmar Gesser
See Also:

  • Constructor Details

  • Method Details

    • isSwitchStatementEntry

      public boolean isSwitchStatementEntry()
      This is required for the ConcreteSyntaxModel, specifically to determine whether this entry uses the classic switch statement syntax (e.g. `case X: ...`) or the newer switch expression syntax (`case X -> ...`). The entry type is STATEMENT_GROUP in the switch statement case and all other values are for the various switch expressions.

    • accept

      public <R,A> R accept(GenericVisitor<R,A> v, A arg)
      Description copied from interface: Visitable
      Accept method for visitor support.
      Specified by:
      accept in interface Visitable
      Type Parameters:
      R - the type of the return value of the visitor
      A - the type the user argument passed to the visitor
      Parameters:
      v - the visitor implementation
      arg - the argument passed to the visitor (of type A)
      Returns:
      the result of the visit (of type R)

    • accept

      public <A> void accept(VoidVisitor<A> v, A arg)
      Description copied from interface: Visitable
      Accept method for visitor support.
      Specified by:
      accept in interface Visitable
      Type Parameters:
      A - the type the argument passed for the visitor
      Parameters:
      v - the visitor implementation
      arg - any value relevant for the visitor (of type A)

    • getLabels

      public NodeList<Expression> getLabels()

    • getStatements

      public NodeList<Statement> getStatements()
      Specified by:
      getStatements in interface NodeWithStatements<SwitchEntry>

    • setLabels

      public SwitchEntry setLabels(NodeList<Expression> labels)
      Sets the label
      Parameters:
      labels - the label, can be null
      Returns:
      this, the SwitchEntry

    • setStatements

      public SwitchEntry setStatements(NodeList<Statement> statements)
      Specified by:
      setStatements in interface NodeWithStatements<SwitchEntry>

    • remove

      public boolean remove(Node node)
      Overrides:
      remove in class Node

    • clone

      public SwitchEntry clone()
      Overrides:
      clone in class Node

    • getMetaModel

      public SwitchEntryMetaModel getMetaModel()
      Overrides:
      getMetaModel in class Node
      Returns:
      get JavaParser specific node introspection information.

    • getType

      public SwitchEntry.Type getType()

    • setType

      public SwitchEntry setType(SwitchEntry.Type type)

    • replace

      public boolean replace(Node node, Node replacementNode)
      Overrides:
      replace in class Node

    • isDefault

      public boolean isDefault()

    • setDefault

      public SwitchEntry setDefault(boolean isDefault)

    • getGuard

      public Optional<Expression> getGuard()

    • setGuard

      public SwitchEntry setGuard(Expression guard)

    • removeGuard

      public SwitchEntry removeGuard()