|
Java Precisely
Version 1.05 of 2000-11-23
Peter Sestoft
Copyright c _ 2000
_
sestoft dina.kvl.dk
IT University of Copenhagen, Denmark
and
Royal Veterinary and Agricultural University, Copenhagen, Denmark
This document gives a concise description of the Java programming language, version 1.1 and later.
It is a quick reference for the reader who has already learnt (or is learning) Java from a standard
textbook and who wants to know the language in more detail.
The document presents general rules (on left-hand pages), and corresponding examples (on righthand
pages). All examples are fragments of legal Java programs. The complete examples are available
at the book website; see below.
Contents
1 Running Java: compilation, loading, and execution 4
2 Names and reserved names 4
3 Java naming conventions 4
4 Comments and program lay-out 4
5 Types 6
5.1 Base types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
5.2 Reference types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
5.3 Array types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
5.4 Subtypes and compatibility . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
5.5 Signatures and subsumption . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
6 Variables, parameters, fields, and scope 8
6.1 Values bound to variables, parameters, or fields . . . . . . . . . . . . . . . . . . . . 8
6.2 Variable declarations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
6.3 Scope of variables, parameters and fields . . . . . . . . . . . . . . . . . . . . . . . . 8
7 Strings 10
8 Arrays 12
8.1 Array creation and access . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
8.2 Multi-dimensional arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
8.3 Array initializers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
9 Classes 14
9.1 Class declarations and class bodies . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
9.2 Top-level classes, nested classes, member classes and local classes . . . . . . . . . . 14
9.3 Class modifiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
9.4 The class modifiers public, final, and abstract . . . . . . . . . . . . . . . . . . 16
9.5 Subclasses, superclasses, class hierarchy, inheritance and overriding . . . . . . . . . 16
9.6 Field declarations in classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
9.7 Member access modifiers: private, protected, public . . . . . . . . . . . . . . . 18
9.8 Method declarations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
9.9 Constructor declarations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
9.10 Initializer blocks, field initializers and initializers . . . . . . . . . . . . . . . . . . . 22
9.11 Nested classes, member classes, local classes, and inner classes . . . . . . . . . . . . 24
9.12 Anonymous classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
10 Classes and objects in the computer 26
11 Expressions 28
11.1 Arithmetic operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
11.2 Logical operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
11.3 Bitwise operators and shift operators . . . . . . . . . . . . . . . . . . . . . . . . . . 30
3
11.4 Assignment expression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
11.5 Conditional expression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
11.6 Object creation expression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
11.7 Instance test expression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
11.8 Field access expression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
11.9 The current object reference this . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
11.10Method call expression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
11.10.1 Method call: parameter passing . . . . . . . . . . . . . . . . . . . . . . . . 36
11.10.2 Method call: determining which method is called . . . . . . . . . . . . . . . 38
11.11Type cast expression and type conversion . . . . . . . . . . . . . . . . . . . . . . . 40
12 Statements 41
12.1 Expression statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
12.2 Block statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
12.3 The empty statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
12.4 Choice statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
12.4.1 The if statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
12.4.2 The if-else statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
12.4.3 The switch statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
12.5 Loop statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
12.5.1 The for statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
12.5.2 The while statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
12.5.3 The do-while statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
12.6 Labelled statements, returns, exits and exceptions . . . . . . . . . . . . . . . . . . . 46
12.6.1 The return statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
12.6.2 The labelled statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
12.6.3 The break statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
12.6.4 The continue statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
12.6.5 The throw statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
12.6.6 The try-catch-finally statement . . . . . . . . . . . . . . . . . . . . . . 48
13 Interfaces 50
13.1 Interface declarations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
13.2 Classes implementing interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
14 Exceptions 52
15 Threads, concurrent execution, and synchronization 54
15.1 Threads and concurrent execution . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
15.2 Locks and the synchronized statement . . . . . . . . . . . . . . . . . . . . . . . . 56
15.3 Operations on threads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
16 Compilation, source file names, class names, and class files 60
17 Packages 60
18 References 62
19 Index 63
4 Comments and program lay-out
1 Running Java: compilation, loading, and execution
Before a Java program can be executed, it must be compiled and loaded. The compiler checks that
the Java program is legal: that the program conforms to the syntax (grammar) for Java programs,
that operators (such as +) are applied to the correct type of operands (such as 5 and x), etc. If so, the
compiler generates so-called class files. Execution then starts by loading the needed class files.
Thus running a Java program involves three stages: compilation (checks that the program is
well-formed), loading (loads and initializes classes), and execution (runs the program code).
2 Names and reserved names
A legal name (of a variable, method, field, parameter, class, or interface) must start with a letter or
dollar sign ($) or underscore (_), and continue with zero or more letters or dollar signs or underscores
or digits (09). Do not use dollar signs in class names. Java is case sensitive: upper case letters are
distinguished from lower case letters. A legal name cannot be one of the following reserved names:
abstract boolean break byte case catch char class const continue
default do double else extends false final finally float for goto if
implements import instanceof int interface long native new null
package private protected public return short static strictfp super switch
synchronized this throw throws transient true try void volatile while
3 Java naming conventions
The following naming conventions are often followed in Java programs, although not enforced by
the compiler:
_
If a name is composed of several words, then each word (except possibly the first one) begins
with an upper case letter. Examples: setLayout, addLayoutComponent.
_
Names of variables, fields, and methods begin with a lower case letter. Examples: vehicle,
currentVehicle.
_
Names of classes and interfaces begin with an upper case letter. Examples: Layout, FlowLayout.
_
Named constants (that is, final variables and fields) are written entirely in upper case (and the
parts of composite names are separated by underscores _). Examples: CENTER, MAX_VALUE.
_
A package name is a sequence of dot-separated lower case names. Example: java.awt.event.
4 Comments and program lay-out
Comments have no effect on the execution of the program, but may be inserted anywhere to help
humans understand the program. There are two forms: one-line comments and delimited comments.
Program lay-out has no effect on the computers execution of the program, but is used to help
humans understand the structure of the program.
Comments and program lay-out 5
Example 1 Comments
class Comment {
// This is a one-line comment; it extends to the end of the line
/* This is a delimited comment,
extending over several lines
*/
int /* This is a delimited comment, extending over part of a line */ x = 117;
}
Example 2 Program lay-out style
class Layout { // Class declaration
int a;
Layout(int a)
{ this.a = a; } // One-line constructor body
int sum(int b) { // Multi-line method body
if (a > 0) // If statement
return a + b; // Single statement
else if (a < 0) { // Nested if-else, block statement
int res = -a + b;
return res * 117;
} else { // a 0 // Terminal else, block statement
int sum = 0;
for (int i=0; i= 1) && (day y) maxyz = z; else maxyz = y;
}
Example 4 Scope of fields, parameters, and variables
class Scope {
... //
void m1(int x) { // declaration of parameter x (#1)
... // x #1 in scope
} //
... //
void m2(int v2) { //
... // x #5 in scope
} //
... //
void m3(int v3) { //
... // x #5 in scope
int x; // declaration of variable x (#2)
... // x #2 in scope
} //
... //
void m4(int v4) { //
... // x #5 in scope
{ //
int x; // declaration of variable x (#3)
... // x #3 in scope
} //
... // x #5 in scope
{ //
int x; // declaration of variable x (#4)
... // x #4 in scope
} //
... // x #5 in scope
} //
... //
int x; // declaration of field x (#5)
... // x #5 in scope
}
10 Strings
7 Strings
A string is an object of the predefined class String. A string literal is a sequence of characters within
double quotes: "New York", "B52", and so on. Internally, a character is stored as a number using
the Unicode character encoding, whose character codes 0127 coincide with the ASCII character
encoding. String literals and character literals may use character escape sequences:
Escape code Meaning
b backspace
t horizontal tab
n newline
f form feed (page break)
r carriage return
" the double quote character
the single quote character
\ the backslash character
ddd the character whose character code is the three-digit octal number ddd
udddd the character whose character code is the four-digit hexadecimal number dddd
Each character escape sequence represents a single character. For example, the letter A has code 65
(decimal), which is written 101 in octal and 0041 in hexadecimal, so the string literal "A101u0041"
is the same as "AAA".
If s1 and s2 are expressions of type String then:
_
s1.length() of type int is the length of s1, that is, the number of characters in s1.
_
s1.equals(s2) of type boolean is true if s1 and s2 contain the same sequence of characters,
false otherwise.
_
s1.charAt(i) of type char is the character at position i in s1, counting from 0. If the index
i is less than 0 or greater than s1.length(), then the exception
StringIndexOutOfBoundsException is thrown.
_
s1.concat(s2) of type String is a new string consisting of the characters of s1 followed by
the characters of s2.
_
s1.toString() of type String is just s1 itself.
_
s1 + v is the same as s1.concat(Integer.toString(v)) when v has type int, and similarly
for the other base types (Section 5.1).
_
s1 + v is the same as s1.concat(v.toString()) when v has reference type and v is not
null; and the same as s1.concat("null") when v is null. In particular, s1 + s2 is the
same as s1.concat(s2) when s2 is not null. Any class C will inherit a default toString
method from class Object (which produces strings of the form C 265734), but class C may
override (redefine) it by declaring a method public String toString() to produce more
useful strings.
_
s1.compareTo(s2) returns a negative integer, zero, or a positive integer, according as s1 precedes,
equals, or follows s2 in the usual lexicographical ordering based on the Unicode character
encoding. If s1 or s2 is null, then the exception NullPointerException is thrown.
_
more String methods are described in the Java class library String section; see Section 18.
Strings 11
Example 5 Equality of strings
String s1 = "abc";
String s2 = s1 + ""; // New object, but contains same text as s1
String s3 = s1; // Same object as s1
String s4 = s1.toString(); // Same object as s1
// The following statements print false, true, true, true, true:
System.out.println("s1 and s2 identical objects: " + (s1 s2));
System.out.println(“s1 and s3 identical objects: “ + (s1 s3));
System.out.println("s1 and s4 identical objects: " + (s1 s4));
System.out.println(“s1 and s2 contain same text: “ + (s1.equals(s2)));
System.out.println(“s1 and s3 contain same text: “ + (s1.equals(s3)));
Example 6 Concatenate all command line arguments
public static void main(String[] args) {
String res = “”;
for (int i=0; is). The unsigned right shift n>>>s of a non-negative n equals n>>s; the
signed right shift of a negative n equals (n>>s)+(2s)+(2Lt y)
{ return y % 4 0 && y % 100 != 0 || y % 400 0; }
Example 36 Bitwise operators and shift operators
class Bitwise {
public static void main(String[] args) throws Exception {
int a = 0×3; // Bit pattern 0011
int b = 0×5; // Bit pattern 0101
println4(a); // Prints 0011
println4(b); // Prints 0101
println4(~a); // Prints 1100
println4(~b); // Prints 1010
println4(a & b); // Prints 0001
println4(a ^ b); // Prints 0110
println4(a | b); // Prints 0111
}
static void println4(int n) {
for (int i=3; i=0; i—)
System.out.print(n >> i & 1);
System.out.println();
}
}
32 Expressions
11.4 Assignment expression
In the assignment expression x = e, the type of e must be a subtype of the type of x. The type of the
expression is the same as the type of x. The assignment is executed by evaluating expression e and
storing its value in variable x, after a widening conversion (Section 11.11) if necessary. When e is a
compile-time constant of type byte, char, short or int, and x has type byte, char or short, then a
narrowing conversion is done automatically, provided the value of e is within the range representable
in x (Section 5.1). The value of the expression x = e is that of x after the assignment.
The assignment operator is right associative, so the multiple assignment x = y = e has the same
meaning as x = (y = e), that is, evaluate the expression e, assign its value to y, and then to x.
When e has reference type (object type or array type), then only a reference to the object or array
is stored in x. Thus the assignment x = e does not copy the object or array; see Example 38.
When x and e have the same type, the compound assignment x += e is equivalent to x = x + e;
however, x is evaluated only once, so in a[i++] += e the variable i is increment only once. When
the type of x is t, different from the type of e, then x += e is equivalent to x = (t)(x + e), in
which the intermediate result (x + e) is converted to type t (Section 11.11); again x is evaluated
only once. The other compound assignment operators -=, *=, and so on, are similar.
Since the value of the expression x += e is that of x after the assignment, and the assignment
operators associate to the right, one can write ps[i] = sum += e to first increment sum by e and
then store the result in ps[i]; see Example 27.
11.5 Conditional expression
The conditional expression e1 ? e2 : e3 is legal if e1 has type boolean, and e2 and e3 both have
numeric types, or both have type boolean, or both have compatible reference types. The conditional
expression is evaluated by first evaluating e1. If e1 evaluates to true, then e2 is evaluated; otherwise
e3 is evaluated. The resulting value is the value of the conditional expression.
11.6 Object creation expression
The object creation expression
new C(actual-list)
creates a new object of class C, by calling that constructor in class C whose signature matches the
arguments in actual-list.
The actual-list is evaluated from left to right to obtain a list of argument values. These argument
values are bound to the constructors parameters, an object of the class is created in the memory, the
non-static fields are given default initial values according to their type, a superclass constructor is
called (explicitly or implicitly), all non-static field initializers and initializer blocks are executed in
order of appearance, and finally the constructor body is executed to initialize the object. The value
of the constructor call expression is the newly created object, whose class is C.
When C is an inner class in class D, and o evaluates to an object of class D, then one may create a
C-object inside o using the syntax o.new C(actual-list); see Example 33.
11.7 Instance test expression
The instance test e instanceof t is evaluated by evaluating e to a value v. If v is not null and is
a reference to an object of class C, where C is a subtype of t, the result is true; otherwise false.
Expressions 33
Example 37 Assignment: widening, narrowing, and truncating compound assignment
The assignment d = 12 performs a widening of 12 from int to double. The assignments b = 123
and b2 = 123+1 perform an implicit narrowing from int to byte, because the right-hand sides
are compile-time constants. The assignment b2 = b1+1 would be illegal because b1+1 is not a
compile-time constant. The assignment b2 = 123+5 would be illegal because, although 123+5 is a
compile-time constant, its value is not representable as a byte (whose range is
_
128___ 127).
double d;
d = 12; // widening conversion from int to double
byte b1 = 123, b2; // narrowing conversion from int to byte
b2 = 123 + 1; // legal: 123+1 is a compile-time constant
b2 = (byte)(b1 + 1); // legal: (byte)(b1 + 1) has type byte
int x = 0;
x += 1.5; // equivalent to: x = (int)(x + 1.5); thus adds 1 to x
Example 38 Assignment does not copy objects
This example uses the Point class from Example 13. Assignment (and parameter passing) copies
only the reference, not the object:
Point p1 = new Point(10, 20);
System.out.println(“p1 is “ + p1); // prints: p1 is (10, 20)
Point p2 = p1; // p1 and p2 refer to same object
p2.move(8, 8);
System.out.println(“p2 is “ + p2); // prints: p2 is (18, 28)
System.out.println(“p1 is “ + p1); // prints: p1 is (18, 28)
Example 39 Compound assignment operators
Compute the product of all elements of array xs:
static double multiply(double[] xs) {
double prod = 1.0;
for (int i=0; i= 0 ? x : -x); }
Example 41 Object creation and instance test
Number n1 = new Integer(17);
Number n2 = new Double(3.14);
// The following statements print: false, true, false, true
System.out.println(“n1 is a Double: “ + (n1 instanceof Double));
System.out.println(“n2 is a Double: “ + (n2 instanceof Double));
System.out.println(“null is a Double: “ + (null instanceof Double));
System.out.println(“n2 is a Number: “ + (n2 instanceof Number));
34 Expressions
11.8 Field access expression
A field access must have one of these three forms
f
C.f
o.f
where C is a class and o an expression of reference type.
A class may have several fields of the same name f; see Section 9.6, Example 19, and Example 42
opposite.
A field access f must refer to a static or non-static field declared in or inherited by a class whose
declaration encloses the field access expression (not shadowed by a field in a nested enclosing class,
or by a variable or parameter of the same name). The class declaring the field is the target class TC.
A field access C.f must refer to a static field in class C or a superclass of C. That class is the
target class TC.
A field access o.f, where expression o has type C, must refer to a static or non-static field in class
C or a superclass of C. That class is the target class TC. To evaluate the field access, the expression o
is evaluated to obtain an object. If the field is static, then the object is ignored, and the value of o.f
is the TC-field f. If the field is non-static, then the value of o must be non-null, and the value of o.f
is found as the value of the TC-field f in object o.
It is informative to contrast non-static field access and non-static method call (Section 11.10):
_
In a non-static field access o.f, the field referred to is determined by the (compile-time) type
of the object expression o.
_
In a non-static method call o.m(...), the method called is determined by the (runtime) class
of the target object: the object to which o evaluates.
11.9 The current object reference this
The name this may be used in non-static code to refer to the current object (Section 9.1). When
non-static code in a given object is executed, the object reference this refers to the object as a
whole. Hence, when f is a field and m is a method (declared in the innermost enclosing class), then
this.f means the same as f (when f has not been shadowed by a variable or parameter of the same
name), and this.m(...) means the same as m(...).
When C is an inner class in an enclosing class D, then inside C the notation D.this refers to the
D object enclosing the inner C object. See Example 28 where TLC.this.nf refers to field nf of the
enclosing class TLC.
Expressions 35
Example 42 Field access
Here we illustrate static and non-static field access in the classes B, C and D from Example 19.
Note that the field referred to by an expression of form o.vf or o.sf is determined by the type of
expression o, not the class of the object to which o evaluates:
public static void main(String[] args) {
C c1 = new C(100); // c1 has type C; object has class C
B b1 = c1; // b1 has type B; object has class C
print(C.sf, B.sf); // Prints 102 121
print(c1.sf, b1.sf); // Prints 102 121
print(c1.vf, b1.vf); // Prints 100 120
C c2 = new C(200); // c2 has type C; object has class C
B b2 = c2; // b2 has type B; object has class C
print(c2.sf, b2.sf); // Prints 202 221
print(c2.vf, b2.vf); // Prints 200 220
print(c1.sf, b1.sf); // Prints 202 221
print(c1.vf, b1.vf); // Prints 100 120
D d3 = new D(300); // d3 has type D; object has class D
C c3 = d3; // c3 has type C; object has class D
B b3 = d3; // b3 has type B; object has class D
print(D.sf, C.sf, B.sf); // Prints 304 304 361
print(d3.sf, c3.sf, b3.sf); // Prints 304 304 361
print(d3.vf, c3.vf, b3.vf); // Prints 300 340 360
}
static void print(int x, int y) { System.out.println(x+” “+y); }
static void print(int x, int y, int z) { System.out.println(x+” “y“ “+z); }
Example 43 Using this when referring to shadowed fields
A common use of this is to refer to fields (this.x and this.y) that have been shadowed by
parameters (x and y), especially in constructors; see the Point class (Example 13):
class Point {
int x, y;
Point(int x, int y) { this.x = x; this.y = y; }
... }
Example 44 Using this to pass the current object to a method
In the SPoint class (Example 14), the current object reference this is used in the constructor to add
the newly created object to the vector allpoints, and it is used in the method getIndex to look up
the current object in the vector:
class SPoint {
static Vector allpoints = new Vector();
int x, y;
SPoint(int x, int y) { allpoints.addElement(this); this.x = x; this.y = y; }
int getIndex() { return allpoints.indexOf(this); }
... }
36 Expressions
11.10 Method call expression
A method call expression, or method invocation, must have one of these four forms:
m(actual-list)
super.m(actual-list)
C.m(actual-list)
o.m(actual-list)
where m is a method name, C is a class name, and o is an expression of reference type. The actual-list
is a possibly empty comma-separated list of expressions, called the arguments or actual parameters.
The call signature is csig
_
m(t1, . . . , tn) where (t1, . . . , tn) is the list of types of the n arguments
in the actual-list.
Determining what method is actually called by a method call is moderately complicated because
(1) method names may be overloaded, each version of the method having a distinct signature; (2)
methods may be overridden, that is, re-implemented in subclasses; (3) non-static methods are called
by dynamic dispatch, given a target object; and (4) a method call in a nested class may call a method
declared in some enclosing class.
Section 11.10.1 describes argument evaluation and parameter passing, assuming the simple case
where it is clear which method m is being called. Section 11.10.2 then describes how to determine
which method is being called in the general case.
11.10.1 Method call: parameter passing
Here we consider the evaluation of a method call m(actual-list) when it is clear which method m is
called, and focus on the parameter passing mechanism.
The call is evaluated by evaluating the expressions in the actual-list from left to right to obtain
the argument values. These argument values are then bound to the corresponding parameters in the
methods formal-list, in order of appearance. A widening conversion (see Section 11.11) occurs if
the type of an argument expression is a subtype of the methods corresponding parameter type.
Java uses call-by-value to bind argument values to formal parameters, so the formal parameter
holds a copy of the argument value. Thus if the method changes the value of a formal parameter,
this change does not affect the argument. For an argument of reference type, the parameter holds a
copy of the object or array reference, and hence the parameter refers to the same object or array as
the actual argument expression. Thus if the method changes that object or array, the changes will be
visible after the method returns (see Example 46).
A non-static method must be called with a target object, for example as o.m(actual-list), where
the target object is the value of o, or as m(actual-list) where the target object is the current object
reference this. In either case, during execution of the method body, this will be bound to the target
object.
A static method is not called with a target object, and it is illegal to use the identifier this inside
the method body.
When the argument values have been bound to the formal parameters, then the method body is
executed. The value of the method call expression is the value returned by the method if its returntype
is non-void; otherwise the method call expression has no value. When the method returns, all
parameters and local variables in the method are discarded.
Expressions 37
Example 45 Calling non-overloaded, non-overridden methods
This program uses the SPoint class from Example 14. The static methods getSize and getPoint
may be called by prefixing them with the class name SPoint or an expression of type SPoint, such
as q. They may be called before any objects have been created. The non-static method getIndex
must be called with an object, as in r.getIndex(); then the method is executed with the current
object reference this bound to r.
public static void main(String[] args) {
System.out.println(“Number of points created: “ + SPoint.getSize());
SPoint p = new SPoint(12, 123);
SPoint q = new SPoint(200, 10);
SPoint r = new SPoint(99, 12);
SPoint s = p;
q = null;
System.out.println(“Number of points created: “ + SPoint.getSize());
System.out.println(“Number of points created: “ + q.getSize());
System.out.println(“r is point number “ + r.getIndex());
for (int i=0; i= 0)
return x;
else
return -x;
}
Example 51 A sequence of if-else statements
We cannot use a switch here, because a switch can work only on integer types (including char):
static int wdayno1(String wday) {
if (wday.equals(“Monday”)) return 1;
else if (wday.equals(“Tuesday”)) return 2;
else if (wday.equals(“Wednesday”)) return 3;
else if (wday.equals(“Thursday”)) return 4;
else if (wday.equals(“Friday”)) return 5;
else if (wday.equals(“Saturday”)) return 6;
else if (wday.equals(“Sunday”)) return 7;
else return -1; // Here used to mean not found
}
Example 52 switch statement
Below we could have used a sequence of if-else statements, but a switch is both faster and clearer:
static String findCountry(int prefix) {
switch (prefix) {
case 1: return “North America”;
case 44: return “Great Britain”;
case 45: return “Denmark”;
case 299: return “Greenland”;
case 46: return “Sweden”;
case 7: return “Russia”;
case 972: return “Israel”;
default: return “Unknown”;
}
}
44 Statements
12.5 Loop statements
12.5.1 The for statement
A for statement has the form
for (initialization; condition; step)
body
where the initialization is a variable-declaration (Section 6.2) or an expression, condition is an
expression of type boolean, step is an expression, and body is a statement. More generally, the
initialization and step may also be comma-separated lists of expressions; the expressions in each
such list are evaluated from left to right. The initialization, condition and step may be empty. An
empty condition is equivalent to true. Thus for (;;) body means forever execute body.
The for statement is executed as follows:
1. The initialization is executed
2. The condition is evaluated. If it is false, the loop terminates.
3. If it is true, then
(a) The body is executed
(b) The step is executed
(c) Execution continues at 2.
12.5.2 The while statement
A while statement has the form
while (condition)
body
where the condition is an expression of type boolean, and body is a statement. The while statement
is executed as follows:
1. The condition is evaluated. If it is false, the loop terminates.
2. If it is true, then
(a) The body is executed
(b) Execution continues at 1.
12.5.3 The do-while statement
A do-while statement has the form
do
body
while (condition);
where the condition is an expression of type boolean, and body is a statement. The body is executed
at least once, because the do-while statement is executed as follows:
1. The body is executed.
2. The condition is evaluated. If it is false, the loop terminates.
3. If it is true, then execution continues at 1.
Statements 45
Example 53 Nested for loops
This program prints a four-line triangle of asterisks (*):
for (int i=1; i
[ Enlace |  Sin comentarios :'( ]  del.icio.us Estrella este post 
General
|
