Java Statements

An Introduction to Java Statements

By Herbert J. Bernstein

This is a brief introduction to and summary of Java Statements. Some portions of the language have been glossed over or omitted here. There is a strong relationship to the statements in C++. For more detail on Java syntax, see [Joy et al., 00]. For information on C++ and C, see see [Ritchie, 78], [Stroustrup, 86] and [Gehani, 88].

Statements

Each portion of a Java program consists of a sequence of statements. Almost all valid C and C++ statements are valid Java statements. One major difference is that there is no goto statement in Java.

Almost all valid Java statements are valid C++ statement. The major exceptions are the synchronized, throw and try statements.

C and C++ have a preprocessor which is not available in Java.

The statements in Java may be organized into:

Comments
Declarations
Method Declarations
Executable statements

Comments

Comments may be of the form:

     // comment \n

      /* comment */

The first form allows a trailing comment on a single line, while the second form allows comments that span multiple lines.

Comments may appear anywhere.

Declarations

In most programming languages, declarations give the compiler information about the types, storage requirements and intial values of identifiers. Java emphasises object-oriented programming, and the major purpose of declarations in Java is to define classes.

The types in Java consist of primitive types (byte, short, char, int, long, float, double, boolean), class types, interface types and array types. Classes, interfaces and arrays are always referenced by what in C would be called a pointer or, in C++, a reference, and thus are called reference types. A special null type (the unnamed type of the special identifier null) is defined to provide a null reference for uninitialized reference types.

A class declaration is one of the forms:

modifiers_opt class identifier class_body
modifiers_opt class identifier extends type class_body
modifiers_opt class identifier implements type_list class_body
modifiers_opt class identifier extends type implements type_list class_body

Java does not permit multiple inheritance, but provides interface declarations instead:

modifiers_opt interface identifier interface_body
modifiers_opt interface identifier extends type_list interface_body

The optional extends clause specifies a single class of which the newly declared class is a subclass. The optional implements clause specifies a list of one or more interfacces for which this class is a subinterface.

The optional modifiers are zero or more of the following:

public -- access from anywhere
protected -- acccess from within the package containg the class
private -- access only from within the top level class
static -- used to declare class methods
abstract -- the class definition is not complete (may contain abstract methods)
final -- no subclasses will be defined to preserve order of accesses.
strictfp -- make all float and double expressions FP-strict (strictly IEEE 754)

The class body is enclosed within curly braces and consists of zero or more declarations of methods and fields (variables of primitive types and instances of objects).

Method Declarations

A method defines an action to be performed by an instance of a class. A constructor is a special method to be invoked when an instances of the class created. The method declarations in Java look like function declarations from C or C++. However, there are no functions in java other than class methods. As with a C function, a Java method can accept a fixed number of positional arguments in the following form:

    modifiers_opt type identifier ( 
        formal_argument_list ) throws_clause_opt{ 
        method_body }

The optional modifiers are zero or more of the following:

public -- access from anywhere
protected -- acccess from within the package containg the class
private -- access only from within the top level class
static -- used to declare class methods
abstract -- the class definition is not complete (may contain abstract methods)
final -- no subclasses will be defined
native -- implemented in platform-dependent code (e.g. C or C++)
synchronized -- forces lock-controlled serialization of access
strictfp -- make all float and double expressions FP-strict (strictly IEEE 754)

The optional throws_clause begins with the keyword throws and is followed by a comma-separated list of class types from the class Throwable

The type of the value returned by the method is given by type, which must either be a known type or the special type, void.

If a method does not have formal arguments, the identifier is followed by an empty pair of parentheses. This conflicts with current recommended C and C++ usage which would handle this case with identifier ( void ). When there are formal arguments, the formal_argument_list is a comma separated list of type declarations of formal parameters. The only optional modifier permitted before the type is final. Arrays are declared by one or more pairs of trailing empty square brackets.

Field Declarations

Java field declarations declare the variables and other storage to be used by instances of a class. These declarations look just like C and C+ variable declarations, but one must remember that they are actually the equivalent of declarations of the members of C struct types. The declarations take one of the forms:

modifiers_opt type identifier ;
modifiers_opt type 
identifier=initializer;

or the same forms with comma separated lists of identifiers or initialized identifiers, or the same forms with arrays indicated by tailing pairs of empty square brackets.

As with C and C++, arrays are defined by delcarations ending with any number pairs square brackets, but in Java, the square brackets are always empty, with arrays being intialized either with new or literal arrays given in curly braces. The optional modifiers are zero or more of the following:

public -- access from anywhere

protected -- acccess from within the package containg the class

private -- access only from within the top level class

static -- used to declare fields with only one (shared) instance, independent of the number of class instances.

final -- a constant; the variable will not be redefined

volatile -- forces threads to conform their working copies to the master copy and to preserve order of accesses.

Executable statements

{ declarations executable_statements }

expression;

if ( expression ) statement

if ( expression ) statement else statement

while ( expression ) statement

do statement while ( expression )

for ( expression_1; expression_2; expression_3 ) statement
equivalent to:
expression_1; while ( expression_2 ) { statement expression_3 }

switch ( expression ) {
declarations
case constant_expression: statement
...
default: statement
}

try { declarations executable_statements }
catch ( formal_argument ) { declarations executable_statements }
... possibly with additional catch clauses ... possibly with a trailing finally clause
synchronized ( expression ) { declarations executable_statements }
break;

break statement_label;

continue;

continue statement_label;;

return;

return expression;

throw expression;

statement_label: executable_statement

See Conditionals.html and Loops.html for more on conditionals and loops.
Operators

C, C++ and Java have a rich repertoire of operators. C++ permits the programmer to overload the existing operators. Java does not. The operators on Java are:

Assignment Operators

= -- simple assignment
+= -- add rhs, then assign to lhs
-= -- subtract rhs, then assign to lhs
*= -- multiply by rhs, then assign to lhs
/= -- divide lhs by rhs, then assign to lhs
&= -- bitwise and, then assign to lhs
|= -- bitwise or, then assign to lhs
^= -- bitwise exclusive or, then assign to lhs
%= -- bitwise remainder, then assign to lhs
<<= -- left shift lhs by rhs, then assign to lhs
>>= -- signed right shift, then assign to lhs
>>>= -- unsigned right shift, then assign to lhs

Infix Operators

|| -- logical or
&& -- logical and
| -- integer bitwise or
^ -- integer bitwise exclusive or
& -- integer bitwise and
== -- numerical equality
!= -- numerical inequality
< -- less than
> -- greater than
<= -- less than or equal to
>= -- greater than or equal to
<< -- left shift
>> -- signed right shift
>>> -- unsignd right shift
+ -- addition or string concatenation
- -- subtraction
* -- multiplication
/ -- division
% -- remainder

Infix Ternary Operator

? : -- conditional expression

Prefix Unary Operators

++ -- unary prefix increment
-- -- unary prefix decrement
! -- unary logical negation
~ -- unary bitwise complement
+ -- unary plus (noop)
- -- unary negate

Postfix Unary Operator

++ -- unary postfix increment
-- -- unary postfix decrement

References

Bill Joy (ed.), Guy Steele, James Gosling, Gilad Bracha, "Java(TM) Language Specification (2nd Edition)" (June 5, 2000) 544 pages, Addison-Wesley Pub Co, ISBN 0201310082
[Ritchie, 78] Ritchie, Dennis M., "The C Programming Language -- Reference Manual", in the "Unix Programmer's Manual, Supplementary Documents", 4.2 Berkeley Software Distribution, Virtual VAX-11 Version, Computer Science Division, Dept. of Electrical Engineering and Computer Science, U. of California, Berkeley, CA, Section 1, March 1984.

[Stroustrup, 86] Stroustrup, Bjarne, "The C++ Programming Language (3^rd edition), Addison Wesley Longman, Reading, MA, 1997, ISBN 0-201-88954-4, 920 pp.

[Gehani, 88] Gehani, Narain, "C: An Advanced Introduction (ANSI C Edition)", Computer Science Press, Inc., Rockville, MD, 1988, ISBN 0-7167-8193-X, 265 pp.,

Last Updated on 11 September 2002
By Herbert J. Bernstein
Email: yaya@bernstein-plus-sons.com