The two basic statements are expression statements and declaration statements, of which you've seen a plethora. Expression statements, such as i++ or method invocations, are expressions that have a semicolon at the end. The semicolon terminates the statement.^[1] In fact, a semicolon by itself is a statement that does nothing—the empty statement. Not all expressions can become statements, since it would be almost always meaningless to have, for example, an expression such as x<= y stand alone as a statement. Only the following types of expressions can be made into statements by adding a terminating semicolon:

Declaration statements (formally called local variable declaration statements) declare a variable and initialize it to a value, as discussed in Section 7.3.1 on page 170. They can appear anywhere inside a block, not just at the beginning. Local variables exist only as long as the block containing their declaration is executing. Local variables must be initialized before use, either by initialization when declared or by assignment. If any local variable is used before it is initialized, the code will not compile.

Local class declaration statements declare a local inner class that can be used within the block in which it was declared. Local classes were discussed in detail on page 142.

In addition to the expression statements listed, several other kinds of statements, such as if and for statements, affect flow of control through the program. This chapter covers each type of statement in detail.

Curly braces, { and }, group zero or more statements into a block. A block can be used where any single statement is allowed because a block is a statement, albeit a compound one.

The most basic form of conditional control flow is the if statement, which chooses whether to execute statements that follow it. Its syntax is:

if (expression)
    statement1
else
    statement2

First, the expression—which must be of type boolean or Boolean—is evaluated. If its value is true, then statement1 is executed; otherwise, if there is an else clause, statement2 is executed. The else clause is optional.

You can build a series of tests by joining another if to the else clause of a previous if. Here is a method that maps a string—expected to be one of a particular set of words—into an action to be performed with a value:

public void setProperty(String keyword, double value)
    throws UnknownProperty
{
    if (keyword.equals("charm"))
        charm(value);
    else if (keyword.equals("strange"))
        strange(value);
    else
        throw new UnknownProperty(keyword);
}

What if there is more than one preceding if without an else? For example:

public double sumPositive(double[] values) {
    double sum = 0.0;

    if (values.length > 1)
        for (int i = 0; i < values.length; i++)
            if (values[i] > 0)
                sum += values[i];
    else    // oops!
        sum = values[0];
    return sum;
}

The else clause looks as if it is bound to the array length check, but that is a mirage of indentation, and indentation is ignored. Instead, an else clause is bound to the most recent if that does not have one. Thus, the previous block of code is equivalent to

public double sumPositive(double[] values) {
    double sum = 0.0;

    if (values.length > 1)
        for (int i = 0; i < values.length; i++)
            if (values[i] > 0)
                sum += values[i];
            else    // oops!
                sum = values[0];
    return sum;
}

This is probably not what was intended. To bind the else clause to the first if, you can use braces to create blocks:

public double sumPositive(double[] values) {
    double sum = 0.0;

    if (values.length > 1) {
        for (int i = 0; i < values.length; i++)
            if (values[i] > 0)
                sum += values[i];
    } else {
        sum = values[0];
    }
    return sum;
}

Exercise 10.1: Using if–else in a loop, write a method that takes a string parameter and returns a string with all the special characters in the original string replaced by their language equivalents. For example, a string with a " in the middle of it should create a return value with that " replaced by ". (Section 7.2.3 on page 167 lists all special characters).

A switch statement allows you to transfer control to a labeled entry point in a block of statements, based on the value of an expression. The general form of a switch statement is:

switch (expression) {
    case n: statements
    case m: statements
    . . .
    default: statements
}

The expression must either be of an integer type (char, byte, short, or int, or a corresponding wrapper class) or an enum type. The body of the switch statement, known as the switch block, contains statements that can be prefixed with case labels. A case label is an integer or enum constant. If the value of the switch expression matches the value of a case label then control is transferred to the first statement following that label. If a matching case label is not found, control is transferred to the first statement following a default label. If there is no default label, the entire switch statement is skipped.

For example, consider our Verbose interface from page 121:

interface Verbose {
    int SILENT  = 0;
    int TERSE   = 1;
    int NORMAL  = 2;
    int VERBOSE = 3;

    void setVerbosity(int level);
    int getVerbosity();
}

Depending on the verbosity level, the state of the object is dumped, adding new output at greater verbosity levels and then printing the output of the next lower level of verbosity:

Verbose v = ... ; // initialized as appropriate
public void dumpState() {
    int verbosity = v.getVerbosity();
    switch (verbosity) {
      case Verbose.SILENT:
        break; // do nothing

      case Verbose.VERBOSE:
        System.out.println(stateDetails);
        // FALLTHROUGH

      case Verbose.NORMAL:
        System.out.println(basicState);
        // FALLTHROUGH

      case Verbose.TERSE:
        System.out.println(summaryState);
        break;

      default:
        throw new IllegalStateException(
                      "verbosity=" + verbosity);
    }
}

Once control has transferred to a statement following a case label, the following statements are executed in turn, according to the semantics of those statements, even if those statements have their own different case labels. The FALLTHROUGH comments in the example show where control falls through the next case label to the code below. Thus, if the verbosity level is VERBOSE, all three output parts are printed; if NORMAL, two parts are printed; and if TERSE, only one part is printed.

A case or default label does not force a break out of the switch. Nor does it imply an end to execution of statements. If you want to stop executing statements in the switch block you must explicitly transfer control out of the switch block. You can do this with a break statement. Within a switch block, a break statement transfers control to the first statement after the switch. This is why we have a break statement after the TERSE output is finished. Without the break, execution would continue through into the code for the default label and throw the exception every time. Similarly, in the SILENT case, all that is executed is the break because there is nothing to print.

Falling through to the next case can be useful in some circumstances. But in most cases a break should come after the code that a case label selects. Good coding style suggests that you always use some form of FALLTHROUGH comment to document an intentional fall-through.

A single statement can have more than one case label, allowing a singular action in multiple cases. For example, here we use a switch statement to decide how to translate a hexadecimal digit into an int:

public int hexValue(char ch) throws NonHexDigitException {
    switch (ch) {
      case '0': case '1': case '2': case '3': case '4':
      case '5': case '6': case '7': case '8': case '9':
        return (ch - '0'),

      case 'a': case 'b': case 'c':
      case 'd': case 'e': case 'f':
        return (ch - 'a') + 10;

      case 'A': case 'B': case 'C':
      case 'D': case 'E': case 'F':
        return (ch - 'A') + 10;

      default:
        throw new NonHexDigitException(ch);
    }
}

There are no break statements because the return statements exit the switch block (and the whole method) before control can fall through.

You should terminate the last group of statements in a switch with a break, return, or throw, as you would a group of statements in an earlier case. Doing so reduces the likelihood of accidentally falling through the bottom of what used to be the last part of the switch when a new case is added.

All case labels must be enum constants or constant expressions—the expressions must contain only literals or named constants initialized with constant expressions—and must be assignable to the type of the switch expression. In any single switch statement, each case value must be unique, and there can be at most one default label.

When you use an enum as a switch expression, you will get no warning if you leave out a case. It is your job to ensure that each case is covered. To safeguard against an enum being redefined to have additional constants, you should always include a default case that simply throws an exception.

Only statements directly within the switch block can have case labels. This means that you cannot, for example, transfer control to a statement within the switch block that is in the middle of a loop, or a statement within a nested block of code. You can, however, skip the declaration and initialization of a local variable within the switch block (not that we recommend it). The effect of this is that the local variable is still considered to be declared, but the initializer has not been executed. Because local variables must be initialized, any attempt to read the value of that variable will result in a compile-time error—the first use of that variable must be an assignment.

The first statement in a switch block must be labeled, otherwise it is unreachable (all cases will jump over it) and your code will not compile.

Exercise 10.2: Rewrite your method from Exercise 10.1 to use a switch.

Exercise 10.3: Using your “days of the week” enum from Exercise 6.1 write a method that takes a day of the week and returns true if it is a working day, and false otherwise. First use nested if–else statements and then a switch statement. Which do you think results in clearer code?

The while loop looks like this:

while (expression)
    statement

The expression—again either of boolean or Boolean type—is evaluated and, if it is true, the statement (which may be a block) is executed. Once the statement completes, the expression is reevaluated and, if still true, the statement is executed again. This repeats until the expression evaluates to false, at which point control transfers to after the while.

We introduced the while loop with our second program in Chapter 1, the Fibonacci program:

while (hi < MAX) {
    System.out.println(hi);
    hi = lo + hi;
    lo = hi - lo;
}

This loops around printing and calculating new Fibonacci values until the highest value computed exceeds the maximum limit.

A while loop executes zero or more times since the expression might be false the first time it is evaluated. Sometimes you want to execute a loop body at least once, which is why you also have a do–while loop:

do
    statement
while (expression);

Here, the expression is evaluated after the statement is executed. While the expression is true, the statement is executed repeatedly. The statement in a do–while loop is almost always a block.

Exercise 10.4: Select a few previous exercise solutions for which you have used a for loop and rewrite it using a while loop. Can you also rewrite it using a do–while loop? Would you do so? If not, why not?

The for statement comes in two forms: a basic and an enhanced form. The basic form is the more general and powerful of the two.

for (initialization-expression;
     loop-expression;
     update-expression)
    statement

{
    initialization-expression;
    while (loop-expression) {
        statement
        update-expression;
    }
}

for (i = 0, j = arr.length - 1; j >= 0; i++, j--) {
    // ...
}

for (int i = 0, j = arr.length - 1; j >= 0; i++, j--) {
    // ...
}

for (int i = 0, Cell node = head;             // INVALID
     i < MAX && node != null;
     i++, node = node.next)
{
    System.out.println(node.getElement());
}

int i;
Cell node;
for (i = 0, node = head;
     i < MAX && node != null;
     i++, node = node.next)
{
    System.out.println(node.getElement());
}

public static int tenPower(int value) {
    int exp, v;
    for (exp = 0, v = value - 1; v > 0; exp++, v /= 10)
        continue;
    return exp;
}

for (;;)
    statement

for (Type loop-variable : set-expression)
     statement

static double average(int[] values) {
    if (values == null || values.length == 0)
        throw new IllegalArgumentException();

    double sum = 0.0;
    for (int val : values)
        sum += val;

    return sum / values.length;
}

for (int j = 0 ; j < values.length; j++) {
    int val = values[j];
    sum += val;
}

static void printAttributes(AttributedImpl obj) {
    for (Attr attr : obj)
        System.out.println(attr);
}

for (Iterator<Attr> iter = obj.iterator();
     iter.hasNext();
     /* no update expression */)
{
    Attr attr = iter.next();
    System.out.println(attr);
}

You can label statements to give them a name by which they can be referred. A label precedes the statement it names; only one label is allowed per statement:

label: statement

Labels can be referred to only by the break and continue statements (discussed next).

A break statement can be used to exit from any block, not just from a switch. There are two forms of break statement. The unlabeled break:

break;

and the labeled break:

break label;

An unlabeled break terminates the innermost switch, for, while, or do statement—and so can appear only within one of those statements. A labeled break can terminate any labeled statement.

A break is most often used to break out of a loop. In this example, we are looking for the first empty slot in an array of references to Contained objects:

class Container {
    private Contained[] objs;

    // ...

    public void addIn(Contained obj)
        throws NoEmptySlotException
    {
        int i;
        for (i = 0; i < objs.length; i++)
            if (objs[i] == null)
                break;
        if (i >= objs.length)
            throw new NoEmptySlotException();
        objs[i] = obj;    // put it inside me
        obj.inside(this); // let it know it's inside me
    }
}

To terminate an outer loop or block, you label the outer statement and use its label name in the break statement:

private float[][] matrix;

public boolean workOnFlag(float flag) {
    int y, x;
    boolean found = false;

  search:
    for (y = 0; y < matrix.length; y++) {
        for (x = 0; x < matrix[y].length; x++) {
            if (matrix[y][x] == flag) {
                found = true;
                break search;
            }
        }
    }
    if (!found)
        return false;

    // do some stuff with flagged value at matrix[y][x]
    return true;
}

Here we label the outer for loop and if we find the value we are looking for, we terminate both inner and outer loops by using a labeled break. This simplifies the logic of the loops because we do not need to add a !found clause in the loop expressions.

Note that a labeled break is not a goto. The goto statement would enable indiscriminate jumping around in code, obfuscating the flow of control. A break or continue that references a label, on the other hand, exits from or repeats only that specific labeled block, and the flow of control is obvious by inspection. For example, here is a modified version of workOnFlag that labels a block instead of a loop, allowing us to dispense with the found flag altogether:

public boolean workOnFlag(float flag) {
    int y, x;

  search:
    {
        for (y = 0; y < matrix.length; y++) {
            for (x = 0; x < matrix[y].length; x++) {
                if (matrix[y][x] == flag)
                    break search;
            }
        }

        // if we get here we didn't find it
        return false;
    }
    // do some stuff with flagged value at matrix[y][x]
    return true;
}

You should use the break statement judiciously, and with thought to the clarity of the resulting code. Arbitrarily jumping out of loops or statements can obscure the flow of control in the code, making it harder to understand and maintain. Some programming styles ban the use of break altogether, but that is an extreme position. Contorting the logic in a loop to avoid the need for a break can result in code that is less clear than it would have been with the break.

A continue statement can be used only within a loop (for, while, or do) and transfers control to the end of the loop's body to continue on with the loop. In the case of while and do loops, this causes the loop expression to be the next thing evaluated. In a basic for loop continue causes the update-expression to be evaluated next and then the loop expression. In the enhanced for loop execution goes to the next element in the set of values if there is one.

Like the break statement, the continue statement has an unlabeled form:

continue;

and a labeled form:

continue label;

In the unlabeled form, continue transfers control to the end of the innermost loop's body. The labeled form transfers control to the end of the loop with that label. The label must belong to a loop statement.

A continue is often used to skip over an element of a loop range that can be ignored or treated with trivial code. For example, a token stream that included a simple “skip” token might be handled this way:

while (!stream.eof()) {
    token = stream.next();
    if (token.equals("skip"))
        continue;
    // ... process token ...
}

A labeled continue will break out of any inner loops on its way to the next iteration of the named loop. No label is required on the continue in the preceding example since there is only one enclosing loop. Consider, however, nested loops that iterate over the values of a two-dimensional matrix. Suppose that the matrix is symmetric (matrix[i][j]== matrix[j][i]). In that case, you need only iterate through half of the matrix. For example, here is a method that doubles each value in a symmetric matrix:

static void doubleUp(int[][] matrix) {
    int order = matrix.length;
  column:
    for (int i = 0; i < order; i++) {
        for (int j = 0; j < order; j++) {
            matrix[i][j] = matrix[j][i] = matrix[i][j]*2;
            if (i == j)
                continue column;
        }
    }
}

Each time a diagonal element of the matrix is reached, the rest of that row is skipped by continuing with the outer loop that iterates over the columns.

A return statement terminates execution of a method and returns to the invoker. If the method returns no value, a simple return statement will do:

return;

If the method has a return type, the return must include an expression of a type that could be assigned to the return type. For example, if a method returns double, a return could have an expression that was a double, float, or integer:

protected double nonNegative(double val) {
    if (val < 0)
        return 0;   // an int constant
    else
        return val; // a double
}

A return can also be used to exit a constructor. Since constructors do not specify a return type, return is used without a value. Constructors are invoked as part of the new process that, in the end, returns a reference to a new object, but each constructor plays only a part of that role; no constructor “returns” the final reference.

The Java programming language has no goto construct that transfers control to an arbitrary statement, although goto is common in languages to which the language is related.^[2] The primary uses for goto in such languages have other solutions:

Labeled break and continue have the advantage that they transfer control to a strictly limited place. A finally block is even stricter as to where it transfers control, and it works in all circumstances, including exceptions. With these constructs you can write clean code without a goto.