Statements

As in C or C++, statements and expressions in Java appear within a code block. A code block is syntactically just a number of statements surrounded by an open curly brace ({) and a close curly brace (}). The statements in a code block can contain variable declarations:

{ 
    int size = 5; 
    setName("Max"); 
    ... 
} 

Methods, which look like C functions, are in a sense code blocks that take parameters and can be called by name.

setupDog( String name ) { 
    int size = 5; 
    setName( name ); 
    ... 
} 

Variable declarations are limited in scope to their enclosing code block. That is, they can't be seen outside of the nearest set of braces:

{ 
    int i = 5; 
} 
 
i = 6;           // compile time error, no such variable i 

In this way, code blocks can be used to arbitrarily group other statements and variables. The most common use of code blocks, however, is to define a group of statements for use in a conditional or iterative statement.

Since a code block is itself collectively treated as a statement, we define a conditional like an if/else clause as follows:

if ( condition ) 
    statement; 
[ else 
    statement; ] 

Thus, if/else in Java has the familiar functionality of taking either of the forms:

if ( condition ) 
    statement; 

or:

if ( condition )  { 
    [ statement; ] 
    [ statement; ] 
    [ ... ] 
} 

Here the condition is a boolean expression. In the second form, the statement is a code block, and all of its enclosed statements are executed if the conditional succeeds. Any variables declared within that block are visible only to the statements within the successful branch of the condition. Like the if/else conditional, most of the remaining Java statements are concerned with controlling the flow of execution. They act for the most part like their namesakes in C or C++.

The do and while iterative statements have the familiar functionality, except that their conditional test is also a boolean expression. You can't use an integer expression or a reference type; in other words you must explicitly test your value. In other words, while i==0 is legitimate, i is not, unless i is boolean. Here are the forms of these two statements:

while ( conditional ) 
    statement; 
 
do 
    statement; 
while ( conditional ); 

The for statement also looks like it does in C:

for ( initialization; conditional; incrementor ) 
    statement; 

The variable initialization expression can declare a new variable; this variable is limited to the scope of the for statement:

for (int i = 0; i < 100; i++ ) { 
    System.out.println( i ) 
    int j = i; 
    ... 
} 

Java doesn't support the C comma operator, which groups multiple expressions into a single expression. However, you can use multiple, comma-separated expressions in the initialization and increment sections of the for loop. For example:

for (int i = 0, j = 10; i < j; i++, j-- ) { 
   ... } 

The Java switch statement takes an integer type (or an argument that can be promoted to an integer type) and selects among a number of alternative case branches[2] :

[2] An object-based switch statement is desirable and could find its way into the language someday.

switch ( int expression ) { 
    case int expression : 
        statement; 
    [ case int expression 
        statement; 
    ... 
    default : 
        statement;  ] 
} 

No two of the case expressions can evaluate to the same value. As in C, an optional default case can be specified to catch unmatched conditions. Normally, the special statement break is used to terminate a branch of the switch:

switch ( retVal ) { 
    case myClass.GOOD : 
        // something good 
        break; 
    case myClass.BAD : 
        // something bad 
        break; 
    default :
        // neither one 
        break; 
} 

The Java break statement and its friend continue perform unconditional jumps out of a loop or conditional statement. They differ from the corresponding statements in C by taking an optional label as an argument. Enclosing statements, like code blocks and iterators, can be labeled with identifier statements:

one: 
    while ( condition ) { 
        ... 
        two: 
            while ( condition ) { 
                ... 
                // break or continue point 
            } 
        // after two 
    } 
// after one 

In the above example, a break or continue without argument at the indicated position would have the normal, C-style effect. A break would cause processing to resume at the point labeled "after two"; a continue would immediately cause the two loop to return to its condition test.

The statement break two at the indicated point would have the same effect as an ordinary break, but break one would break two levels and resume at the point labeled "after one." Similarly, continue two would serve as a normal continue, but continue one would return to the test of the one loop. Multilevel break and continue statements remove much of the need for the evil goto statement in C and C++.

There are a few Java statements we aren't going to discuss right now. The try, catch, and finally statements are used in exception handling, as we'll discuss later in this chapter. The synchronized statement in Java is used to coordinate access to statements among multiple threads of execution; see Chapter 6, Threads for a discussion of thread synchronization.

On a final note, I should mention that the Java compiler flags "unreachable" statements as compile-time errors. Of course, when I say unreachable, I mean those statements the compiler determines won't be called by a static look at compile-time.

Expressions

As I said earlier, expressions are statements that produce a result when they are evaluated. The value of an expression can be a numeric type, as in an arithmetic expression; a reference type, as in an object allocation; or the special type void, which results from a call to a method that doesn't return a value. In the last case, the expression is evaluated only for its side effects (i.e., the work it does aside from producing a value). The type of an expression is known at compile-time. The value produced at run-time is either of this type or, in the case of a reference type, a compatible (assignable) type.

int i, j; 
i = 5;                           // expression 

j = ( i = 5 ); 

int i; 
String s; 
i = myObject.length; 
s = myObject.name; 

int len = myObject.name.length(); 
int initialLen = myObject.name.substring(5, 10).length(); 

System.out.println( "Hello World..." ); 
int myLength = myString.length();  

Object o = new Object(); 

int hours = new Date().getHours(); 

Boolean b; 
String str = "foo"; 
b = ( str instanceof String );     // true 
b = ( str instanceof Object );     // also true 
b = ( str instanceof Date );       // false--not a Date or subclass 

        if ( foo instanceof byte[] )
            ...

String s = null;
if ( s istanceof String )
    // won't happen