CHAPTER 15

Expressions

Much of the work in a Java program is done by evaluating expressions, either for their side effects, such as assignments to variables, or for their values, which can be used as arguments or operands in larger expressions, or to affect the execution sequence in statements, or both.

This chapter specifies the meanings of Java expressions and the rules for their evaluation.

15.1 Evaluation, Denotation, and Result

• A variable (§4.5) (in C, this would be called an lvalue)
• A value (§4.2, §4.3)
• Nothing (the expression is said to be void)

An expression denotes nothing if and only if it is a method invocation (§15.11) that invokes a method that does not return a value, that is, a method declared void (§8.4). Such an expression can be used only as an expression statement (§14.7), because every other context in which an expression can appear requires the expression to denote something. An expression statement that is a method invocation may also invoke a method that produces a result; in this case the value returned by the method is quietly discarded.

Each expression occurs in the declaration of some (class or interface) type that is being declared: in a field initializer, in a static initializer, in a constructor declaration, or in the code for a method.

15.2 Variables as Values

15.3 Type of an Expression

The value of an expression is always assignment compatible (§5.2) with the type of the expression, just as the value stored in a variable is always compatible with the type of the variable. In other words, the value of an expression whose type is T is always suitable for assignment to a variable of type T.

Note that an expression whose type is a class type F that is declared final is guaranteed to have a value that is either a null reference or an object whose class is F itself, because final types have no subclasses.

15.4 Expressions and Run-Time Checks

• Method invocation (§15.11). The particular method used for an invocation o.m(...) is chosen based on the methods that are part of the class or interface that is the type of o. For instance methods, the class of the object referenced by the run-time value of o participates because a subclass may override a specific method already declared in a parent class so that this overriding method is invoked. (The overriding method may or may not choose to further invoke the original overridden m method.)
• The instanceof operator (§15.19.2). An expression whose type is a reference type may be tested using instanceof to find out whether the class of the object referenced by the run-time value of the expression is assignment compatible (§5.2) with some other reference type.
• Casting (§5.4, §15.15). The class of the object referenced by the run-time value of the operand expression might not be compatible with the type specified by the cast. For reference types, this may require a run-time check that throws an error if the class of the referenced object, as determined at run time, is not assignment compatible (§5.2) with the target type.
• Assignment to an array component of reference type (§10.10, §15.12, §15.25.1). The type-checking rules allow the array type S[] to be treated as a subtype of T[] if S is a subtype of T, but this requires a run-time check for assignment to an army component, similar to the check performed for a cast.
• Exception handling (§14.18). An exception is caught by a catch clause only if the class of the thrown exception object is an instanceof the type of the formal parameter of the catch clause.

• In a cast, when the actual class of the object referenced by the value of the operand expression is not compatible with the target type specified by the cast operator (§5.4, §15.15); in this case a ClassCastException is thrown.
• In an assignment to an array component of reference type, when the actual class of the object referenced by the value to be assigned is not compatible with the actual run-time component type of the array (§10.10, §15.12, §15.25.1); in this case an ArrayStoreException is thrown.
• When an exception is not caught by any catch handler (§11.3); in this case the thread of control that encountered the exception first invokes the method uncaughtException (§20.21.31) for its thread group and then terminates.

15.5 Normal and Abrupt Completion of Evaluation

If, however, evaluation of an expression throws an exception, then the expression is said to complete abruptly. An abrupt completion always has an associated reason, which is always a throw with a given value.

Run-time exceptions are thrown by the predefined operators as follows:

• A class instance creation expression (§15.8), array creation expression (§15.9), or string concatenation operatior expression (§15.17.1) throws an OutOfMemoryError if there is insufficient memory available.
• An array creation expression throws an ArrayNegativeSizeException if the value of any dimension expression is less than zero (§15.9).
• A field access (§15.10) throws a NullPointerException if the value of the object reference expression is null.
• A method invocation expression (§15.11) that invokes an instance method throws a NullPointerException if the target reference is null.
• An array access (§15.12) throws a NullPointerException if the value of the array reference expression is null.
• An array access (§15.12) throws an IndexOutOfBoundsException if the value of the array index expression is negative or greater than or equal to the length of the array.
• A cast (§15.15) throws a ClassCastException if a cast is found to be impermissible at run time.
• An integer division (§15.16.2) or integer remainder (§15.16.3) operator throws an ArithmeticException if the value of the right-hand operand expression is zero.
• An assignment to an array component of reference type (§15.25.1) throws an ArrayStoreException when the value to be assigned is not compatible with the component type of the array.

If an exception occurs, then evaluation of one or more expressions may be terminated before all steps of their normal mode of evaluation are complete; such expressions are said to complete abruptly. The terms "complete normally" and "complete abruptly" are also applied to the execution of statements (§14.1). A statement may complete abruptly for a variety of reasons, not just because an exception is thrown.

If evaluation of an expression requires evaluation of a subexpression, abrupt completion of the subexpression always causes the immediate abrupt completion of the expression itself, with the same reason, and all succeeding steps in the normal mode of evaluation are not performed.

15.6 Evaluation Order

It is recommended that Java code not rely crucially on this specification. Code is usually clearer when each expression contains at most one side effect, as its outermost operation, and when code does not depend on exactly which exception arises as a consequence of the left-to-right evaluation of expressions.

15.6.1 Evaluate Left-Hand Operand First

Thus:

class Test {
	public static void main(String[] args) {
		int i = 2;
		int j = (i=3) * i;
		System.out.println(j);
	}
}

9

If the operator is a compound-assignment operator (§15.25.2), then evaluation of the left-hand operand includes both remembering the variable that the left-hand operand denotes and fetching and saving that variable's value for use in the implied combining operation. So, for example, the test program:

class Test {
	public static void main(String[] args) {
		int a = 9;
		a += (a = 3);									// first example
		System.out.println(a);
		int b = 9;
		b = b + (b = 3);									// second example
		System.out.println(b);
	}
}

12
12

If evaluation of the left-hand operand of a binary operator completes abruptly, no part of the right-hand operand appears to have been evaluated.

Thus, the test program:

class Test {

	public static void main(String[] args) {

		int j = 1;

		try {
			int i = forgetIt() / (j = 2);
		} catch (Exception e) {
			System.out.println(e);
			System.out.println("Now j = " + j);
		}
	}

	static int forgetIt() throws Exception {
		throw new Exception("I'm outta here!");
	}
}

java.lang.Exception: I'm outta here!
Now j = 1

15.6.2 Evaluate Operands before Operation

If the binary operator is an integer division / (§15.16.2) or integer remainder % (§15.16.3), then its execution may raise an ArithmeticException, but this exception is thrown only after both operands of the binary operator have been evaluated and only if these evaluations completed normally.

So, for example, the program:

class Test {

	public static void main(String[] args) {
		int divisor = 0;
		try {
			int i = 1 / (divisor * loseBig());
		} catch (Exception e) {
			System.out.println(e);
		}
	}


	static int loseBig() throws Exception {
		throw new Exception("Shuffle off to Buffalo!");
	}

}

java.lang.Exception: Shuffle off to Buffalo!

java.lang.ArithmeticException: / by zero

15.6.3 Evaluation Respects Parentheses and Precedence

In the case of floating-point calculations, this rule applies also for infinity and not-a-number (NaN) values. For example, !(x<y) may not be rewritten as x>=y, because these expressions have different values if either x or y is NaN.

Specifically, floating-point calculations that appear to be mathematically associative are unlikely to be computationally associative. Such computations must not be naively reordered. For example, it is not correct for a Java compiler to rewrite 4.0*x*0.5 as 2.0*x; while roundoff happens not to be an issue here, there are large values of x for which the first expression produces infinity (because of overflow) but the second expression produces a finite result.

So, for example, the test program:

class Test {

	public static void main(String[] args) {
		double d = 8e+307;
		System.out.println(4.0 * d * 0.5);
		System.out.println(2.0 * d);
	}
}

Infinity
1.6e+308

In contrast, integer addition and multiplication are provably associative in Java; for example a+b+c, where a, b, and c are local variables (this simplifying assumption avoids issues involving multiple threads and volatile variables), will always produce the same answer whether evaluated as (a+b)+c or a+(b+c); if the expression b+c occurs nearby in the code, a smart compiler may be able to use this common subexpression.

15.6.4 Argument Lists are Evaluated Left-to-Right

Thus:

class Test {

	public static void main(String[] args) {
		String s = "going, ";
		print3(s, s, s = "gone");
	}

	static void print3(String a, String b, String c) {
		System.out.println(a + b + c);
	}
}

going, going, gone

If evaluation of an argument expression completes abruptly, no part of any argument expression to its right appears to have been evaluated.

Thus, the example:

class Test {
	static int id;
	public static void main(String[] args) {
		try {
			test(id = 1, oops(), id = 3);
		} catch (Exception e) {
			System.out.println(e + ", id=" + id);
		}
	}

	static int oops() throws Exception {
		throw new Exception("oops");
	}

	static int test(int a, int b, int c) {
		return a + b + c;
	}

}

java.lang.Exception: oops, id=1

15.6.5 Evaluation Order for Other Expressions

• class instance creation expressions (§15.8.1)
• array creation expressions (§15.9.1)
• method invocation expressions (§15.11.4)
• array access expressions (§15.12.1)
• assignments involving array components (§15.25)

15.7 Primary Expressions

Primary:

	PrimaryNoNewArray

	ArrayCreationExpression

PrimaryNoNewArray:

	Literal

	this

	( Expression )

	ClassInstanceCreationExpression

	FieldAccess

	MethodInvocation

	ArrayAccess

The technical reasons have to do with allowing left-to-right parsing of Java programs with only one-token lookahead. Consider the expressions (z[3]) and (z[]). The first is a parenthesized array access (§15.12) and the second is the start of a cast (§15.15). At the point that the look-ahead symbol is [, a left-to-right parse will have reduced the z to the nonterminal Name. In the context of a cast we prefer not to have to reduce the name to a Primary, but if Name were one of the alternatives for Primary, then we could not tell whether to do the reduction (that is, we could not determine whether the current situation would turn out to be a parenthesized array access or a cast) without looking ahead two tokens, to the token following the [. The Java grammar presented here avoids the problem by keeping Name and Primary separate and allowing either in certain other syntax rules (those for MethodInvocation, ArrayAccess, PostfixExpression, but not for FieldAccess, because this is covered by Name). This strategy effectively defers the question of whether a Name should be treated as a Primary until more context can be examined. (Other problems remain with cast expressions; see §19.1.5.)

The second unusual feature avoids a potential grammatical ambiguity in the expression:

new int[3][3]

(new int[3])[3]

15.7.1 Literals

The following production from §3.10 is repeated here for convenience:

Literal:

	IntegerLiteral

	FloatingPointLiteral

	BooleanLiteral

	CharacterLiteral

	StringLiteral

	NullLiteral

• The type of an integer literal that ends with L or l is long; the type of any other integer literal is int.
• The type of a floating-point literal that ends with F or f is float; the type of any other floating-point literal is double.
• The type of a boolean literal is boolean.
• The type of a character literal is char.
• The type of a string literal is String.
• The type of the null literal null is the null type; its value is the null reference.

15.7.2 this

When used as a primary expression, the keyword this denotes a value, that is a reference to the object for which the instance method was invoked (§15.11), or to the object being constructed. The type of this is the class C within which the keyword this occurs. At run time, the class of the actual object referred to may be the class C or any subclass of C.

In the example:

class IntVector {
	int[] v;
	boolean equals(IntVector other) {
		if (this == other)
			return true;
		if (v.length != other.v.length)
			return false;
		for (int i = 0; i < v.length; i++)
			if (v[i] != other.v[i])
				return false;
		return true;
	}

}

The keyword this is also used in a special explicit constructor invocation statement, which can appear at the beginning of a constructor body (§8.6.5).

15.7.3 Parenthesized Expressions

15.8 Class Instance Creation Expressions

ClassInstanceCreationExpression:

	new ClassType ( ArgumentListopt )

ArgumentList:

	Expression

	ArgumentList , Expression

The arguments in the argument list, if any, are used to select a constructor declared in the body of the named class type, using the same matching rules as for method invocations (§15.11). As in method invocations, a compile-time method matching error results if there is no unique constructor that is both applicable to the provided arguments and the most specific of all the applicable constructors.

15.8.1 Run-time Evaluation of Class Instance Creation Expressions

First, space is allocated for the new class instance. If there is insufficient space to allocate the object, evaluation of the class instance creation expression completes abruptly by throwing an OutOfMemoryError (§15.8.2).

The new object contains new instances of all the fields declared in the specified class type and all its superclasses. As each new field instance is created, it is initialized to its standard default value (§4.5.4).

Next, the argument list is evaluated, left-to-right. If any of the argument evaluations completes abruptly, any argument expressions to its right are not evaluated, and the class instance creation expression completes abruptly for the same reason.

Next, the selected constructor of the specified class type is invoked. This results in invoking at least one constructor for each superclass of the class type. This process can be directed by explicit constructor invocation statements (§8.6) and is described in detail in §12.5.

The value of a class instance creation expression is a reference to the newly created object of the specified class. Every time the expression is evaluated, a fresh object is created.

15.8.2 Example: Evaluation Order and Out-of-Memory Detection

So, for example, the test program:

class List {
	int value;
	List next;
	static List head = new List(0);
	List(int n) { value = n; next = head; head = this; }
}

class Test {
	public static void main(String[] args) {
		int id = 0, oldid = 0;
		try {
			for (;;) {
				++id;
				new List(oldid = id);
			}
		} catch (Error e) {
			System.out.println(e + ", " + (oldid==id));
		}
	}
}

java.lang.OutOfMemoryError: List, false

Compare this to the treatment of array creation expressions (§15.9), for which the out-of-memory condition is detected after evaluation of the dimension expressions (§15.9.3).

15.9 Array Creation Expressions

ArrayCreationExpression:

	new PrimitiveType DimExprs Dimsopt

	new TypeName DimExprs Dimsopt

DimExprs:

	DimExpr

	DimExprs DimExpr

DimExpr:

	[ Expression ]

Dims:

	[ ]

	Dims [ ]

The type of the creation expression is an array type that can denoted by a copy of the creation expression from which the new keyword and every DimExpr expression have been deleted; for example, the type of the creation expression:

new double[3][3][]

double[][][]

15.9.1 Run-time Evaluation of Array Creation Expressions

First, the dimension expressions are evaluated, left-to-right. If any of the expression evaluations completes abruptly, the expressions to the right of it are not evaluated.

Next, the values of the dimension expressions are checked. If the value of any DimExpr expression is less than zero, then an NegativeArraySizeException is thrown.

Next, space is allocated for the new array. If there is insufficient space to allocate the array, evaluation of the array creation expression completes abruptly by throwing an OutOfMemoryError.

Then, if a single DimExpr appears, a single-dimensional array is created of the specified length, and each component of the array is initialized to its standard default value (§4.5.4).

If an array creation expression contains N DimExpr expressions, then it effectively executes a set of nested loops of depth to create the implied arrays of arrays. For example, the declaration:

float[][] matrix = new float[3][3];

float[][] matrix = new float[3][];
for (int d = 0; d < matrix.length; d++)
	matrix[d] = new float[3];

Age[][][][][] Aquarius = new Age[6][10][8][12][];

Age[][][][][] Aquarius = new Age[6][][][][];
for (int d1 = 0; d1 < Aquarius.length; d1++) {
	Aquarius[d1] = new Age[8][][][];
	for (int d2 = 0; d2 < Aquarius[d1].length; d2++) {
		Aquarius[d1][d2] = new Age[10][][];
		for (int d3 = 0; d3 < Aquarius[d1][d2].length; d3++) {
			Aquarius[d1][d2][d3] = new Age[12][];
		}
	}
}

Age[] Hair = { new Age("quartz"), new Age("topaz") };
Aquarius[1][9][6][9] = Hair;

float triang[][] = new float[100][];
for (int i = 0; i < triang.length; i++)
	triang[i] = new float[i+1];

15.9.2 Example: Array Creation Evaluation Order

Thus:

class Test {
	public static void main(String[] args) {
		int i = 4;
		int ia[][] = new int[i][i=3];
		System.out.println(
			"[" + ia.length + "," + ia[0].length + "]");
	}
}

[4,3]

If evaluation of a dimension expression completes abruptly, no part of any dimension expression to its right will appear to have been evaluated. Thus, the example:

class Test {

	public static void main(String[] args) {
		int[][] a = { { 00, 01 }, { 10, 11 } };
		int i = 99;
		try {
			a[val()][i = 1]++;
		} catch (Exception e) {
			System.out.println(e + ", i=" + i);
		}
	}

	static int val() throws Exception {
		throw new Exception("unimplemented");
	}

}

java.lang.Exception: unimplemented, i=99

15.9.3 Example: Array Creation and Out-of-Memory Detection

So, for example, the test program:

class Test {
	public static void main(String[] args) {
		int len = 0, oldlen = 0;
		Object[] a = new Object[0];
		try {
			for (;;) {
				++len;
				Object[] temp = new Object[oldlen = len];
				temp[0] = a;
				a = temp;
			}
		} catch (Error e) {
			System.out.println(e + ", " + (oldlen==len));
		}
	}
}

java.lang.OutOfMemoryError, true

Compare this to class instance creation expressions (§15.8), which detect the out-of-memory condition before evaluating argument expressions (§15.8.2).

15.10 Field Access Expressions

FieldAccess:

	Primary . Identifier

	super . Identifier

15.10.1 Field Access Using a Primary

• If the identifier names several accessible member fields of type T, then the field access is ambiguous and a compile-time error occurs.
• If the identifier does not name an accessible member field of type T, then the field access is undefined and a compile-time error occurs.
• Otherwise, the identifier names a single accessible member field of type T and the type of the field access expression is the declared type of the field. At run time, the result of the field access expression is computed as follows:
  • If the field is static:
    • If the field is final, then the result is the value of the specified class variable in the class or interface that is the type of the Primary expression.
    • If the field is not final, then the result is a variable, namely, the specified class variable in the class that is the type of the Primary expression.
  • If the field is not static:
    • If the value of the Primary is null, then a NullPointerException is thrown.
    • If the field is final, then the result is the value of the specified instance variable in the object referenced by the value of the Primary.
    • If the field is not final, then the result is a variable, namely, the specified instance variable in the object referenced by the value of the Primary.

Thus, the example:

class S { int x = 0; }
class T extends S { int x = 1; }
class Test {
	public static void main(String[] args) {

		T t = new T();
		System.out.println("t.x=" + t.x + when("t", t));

		S s = new S();
		System.out.println("s.x=" + s.x + when("s", s));

		s = t;
		System.out.println("s.x=" + s.x + when("s", s));

	}


	static String when(String name, Object t) {
		return " when " + name + " holds a "
			+ t.getClass() + " at run time.";
	}
}

t.x=1 when t holds a class T at run time.
s.x=0 when s holds a class S at run time.
s.x=0 when s holds a class T at run time.

This lack of dynamic lookup for field accesses allows Java to run efficiently with straightforward implementations. The power of late binding and overriding is available in Java, but only when instance methods are used. Consider the same example using instance methods to access the fields:

class S { int x = 0; int z() { return x; } }
class T extends S { int x = 1; int z() { return x; } }
class Test {

	public static void main(String[] args) {
		T t = new T();
		System.out.println("t.z()=" + t.z() + when("t", t));
		S s = new S();
		System.out.println("s.z()=" + s.z() + when("s", s));
		s = t;
		System.out.println("s.z()=" + s.z() + when("s", s));
	}

	static String when(String name, Object t) {
		return " when " + name + " holds a "
			+ t.getClass() + " at run time.";
	}
}

t.z()=1 when t holds a class T at run time.
s.z()=0 when s holds a class S at run time.
s.z()=1 when s holds a class T at run time.

The following example demonstrates that a null reference may be used to access a class (static) variable without causing an exception:

class Test {
	static String mountain = "Chocorua";

	static Test favorite(){
		System.out.print("Mount ");
		return null;
	}

	public static void main(String[] args) {
		System.out.println(favorite().mountain);
	}
}

Mount Chocorua

15.10.2 Accessing Superclass Members using super

Suppose that a field access expression super.name appears within class C, and the immediate superclass of C is class S. Then super.name is treated exactly as if it had been the expression ((S)this).name; thus, it refers to the field named name of the current object, but with the current object viewed as an instance of the superclass. Thus it can access the field named name that is visible in class S, even if that field is hidden by a declaration of a field named name in class C.

The use of super is demonstrated by the following example:

interface I { int x = 0; }
class T1 implements I { int x = 1; }
class T2 extends T1 { int x = 2; }
class T3 extends T2 {
	int x = 3;
	void test() {
		System.out.println("x=\t\t"+x);
		System.out.println("super.x=\t\t"+super.x);
		System.out.println("((T2)this).x=\t"+((T2)this).x);
		System.out.println("((T1)this).x=\t"+((T1)this).x);
		System.out.println("((I)this).x=\t"+((I)this).x);
	}
}
class Test {
	public static void main(String[] args) {
		new T3().test();
	}
}

x=					3
super.x=					2
((T2)this).x=					2
((T1)this).x=					1
((I)this).x=					0

((T2)this).x

15.11 Method Invocation Expressions

MethodInvocation:

	MethodName ( ArgumentListopt )

	Primary . Identifier ( ArgumentListopt )

	super . Identifier ( ArgumentListopt )

ArgumentList:

	Expression

	ArgumentList , Expression

Determining the method that will be invoked by a method invocation expression involves several steps. The following three sections describe the compile-time processing of a method invocation; the determination of the type of the method invocation expression is described in §15.11.3.

15.11.1 Compile-Time Step 1: Determine Class or Interface to Search

• If the form is MethodName, then there are three subcases:
  • If it is a simple name, that is, just an Identifier, then the name of the method is the Identifier and the class or interface to search is the one whose declaration contains the method invocation.
  • If it is a qualified name of the form TypeName . Identifier, then the name of the method is the Identifier and the class to search is the one named by the TypeName. If TypeName is the name of an interface rather than a class, then a compile-time error occurs, because this form can invoke only static methods and interfaces have no static methods.
  • In all other cases, the qualified name has the form FieldName . Identifier; then the name of the method is the Identifier and the class or interface to search is the declared type of the field named by the FieldName.
• If the form is Primary . Identifier, then the name of the method is the Identifier and the class or interface to be searched is the type of the Primary expression.
• If the form is super . Identifier, then the name of the method is the Identifier and the class to be searched is the superclass of the class whose declaration contains the method invocation. A compile-time error occurs if such a method invocation occurs in an interface, or in the class Object, or in a static method, a static initializer, or the initializer for a static variable. It follows that a method invocation of this form may appear only in a class other than Object, and only in the body of an instance method, the body of a constructor, or an initializer for an instance variable.

15.11.2 Compile-Time Step 2: Determine Method Signature

15.11.2.1 Find Methods that are Applicable and Accessible

• The number of parameters in the method declaration equals the number of argument expressions in the method invocation.
• The type of each actual argument can be converted by method invocation conversion (§5.3) to the type of the corresponding parameter. Method invocation conversion is the same as assignment conversion (§5.2), except that constants of type int are never implicitly narrowed to byte, short, or char.

Whether a method declaration is accessible to a method invocation depends on the access modifier (public, none, protected, or private) in the method declaration and on where the method invocation appears.

If the class or interface has no method declaration that is both applicable and accessible, then a compile-time error occurs.

In the example program:

public class Doubler {
	static int two() { return two(1); }
	private static int two(int i) { return 2*i; }
}

class Test extends Doubler {	
	public static long two(long j) {return j+j; }

	public static void main(String[] args) {
		System.out.println(two(3));
		System.out.println(Doubler.two(3)); // compile-time error
	}
}

Another example is:

class ColoredPoint {
	int x, y;
	byte color;
	void setColor(byte color) { this.color = color; }
}

class Test {
	public static void main(String[] args) {
		ColoredPoint cp = new ColoredPoint();
		byte color = 37;
		cp.setColor(color);
		cp.setColor(37);											// compile-time error
	}
}

If the method setColor had, however, been declared to take an int instead of a byte, then both method invocations would be correct; the first invocation would be allowed because method invocation conversion does permit a widening conversion from byte to int. However, a narrowing cast would then be required in the body of setColor:

	void setColor(int color) { this.color = (byte)color; }

15.11.2.2 Choose the Most Specific Method

The informal intuition is that one method declaration is more specific than another if any invocation handled by the first method could be passed on to the other one without a compile-time type error.

The precise definition is as follows. Let m be a name and suppose that there are two declarations of methods named m, each having n parameters. Suppose that one declaration appears within a class or interface T and that the types of the parameters are T1, . . . , Tn; suppose moreover that the other declaration appears within a class or interface U and that the types of the parameters are U1, . . . , Un. Then the method m declared in T is more specific than the method m declared in U if and only if both of the following are true:

• T can be converted to U by method invocation conversion.
• Tj can be converted to Uj by method invocation conversion, for all j from 1 to n.

If there is exactly one maximally specific method, then it is in fact the most specific method; it is necessarily more specific than any other method that is applicable and accessible. It is then subjected to some further compile-time checks as described in §15.11.3.

It is possible that no method is the most specific, because there are two or more maximally specific method declarations. In this case, we say that the method invocation is ambiguous, and a compile-time error occurs.

15.11.2.3 Example: Overloading Ambiguity

class Point { int x, y; }
class ColoredPoint extends Point { int color; }

class Test {

	static void test(ColoredPoint p, Point q) {
		System.out.println("(ColoredPoint, Point)");
	}

	static void test(Point p, ColoredPoint q) {
		System.out.println("(Point, ColoredPoint)");
	}

	public static void main(String[] args) {
		ColoredPoint cp = new ColoredPoint();
		test(cp, cp);											// compile-time error
	}
}

If a third definition of test were added:

	static void test(ColoredPoint p, ColoredPoint q) {
		System.out.println("(ColoredPoint, ColoredPoint)");
	}

15.11.2.4 Example: Return Type Not Considered

class Point { int x, y; }
class ColoredPoint extends Point { int color; }
class Test {

	static int test(ColoredPoint p) {
		return color;
	}

	static String test(Point p) {
		return "Point";
	}

	public static void main(String[] args) {
		ColoredPoint cp = new ColoredPoint();
		String s = test(cp);											// compile-time error
	}
}

15.11.2.5 Example: Compile-Time Resolution

So, for example, consider two compilation units, one for class Point:

package points;
public class Point {
	public int x, y;
	public Point(int x, int y) { this.x = x; this.y = y; }
	public String toString() { return toString(""); }

	public String toString(String s) {
		return "(" + x + "," + y + s + ")";
	}
}

package points;
public class ColoredPoint extends Point {

	public static final int
		RED = 0, GREEN = 1, BLUE = 2;

	public static String[] COLORS =
		{ "red", "green", "blue" };
	public byte color;

	public ColoredPoint(int x, int y, int color) {
		super(x, y); this.color = (byte)color;
	}

	/** Copy all relevant fields of the argument into
		    this ColoredPoint object. */
	public void adopt(Point p) { x = p.x; y = p.y; }

	public String toString() {
		String s = "," + COLORS[color];
		return super.toString(s);
	}
}

import points.*;
class Test {
	public static void main(String[] args) {
		ColoredPoint cp =
			new ColoredPoint(6, 6, ColoredPoint.RED);
		ColoredPoint cp2 =
			new ColoredPoint(3, 3, ColoredPoint.GREEN);
		cp.adopt(cp2);
		System.out.println("cp: " + cp);
	}
}

cp: (3,3,red)

Notice, by the way, that the most specific method (indeed, the only applicable method) for the method invocation of adopt has a signature that indicates a method of one parameter, and the parameter is of type Point. This signature becomes part of the binary representation of class Test produced by the compiler and is used by the method invocation at run time.

Suppose the programmer reported this software error and the maintainer of the points package decided, after due deliberation, to correct it by adding a method to class ColoredPoint:

public void adopt(ColoredPoint p) {
	adopt((Point)p); color = p.color;
}

cp: (3,3,red)

cp: (3,3,green)

public void adopt(Point p) {
	if (p instanceof ColoredPoint)
		color = ((ColoredPoint)p).color;
	x = p.x; y = p.y;
}

public void adopt(Point p) {
	if (p instanceof ColoredPoint)
		color = ((ColoredPoint)p).color;
	super.adopt(p);
}

15.11.3 Compile-Time Step 3: Is the Chosen Method Appropriate?

• If the method invocation has, before the left parenthesis, a MethodName of the form Identifier, and the method invocation appears within a static method, a static initializer, or the initializer for a static variable, then the compile-time declaration must be static. If, instead, the compile-time declaration for the method invocation is for an instance method, then a compile-time error occurs. (The reason is that a method invocation of this form cannot be used to invoke an instance method in places where this (§15.7.2) is not defined.)
• If the method invocation has, before the left parenthesis, a MethodName of the form TypeName . Identifier, then the compile-time declaration should be static. If the compile-time declaration for the method invocation is for an instance method, then a compile-time error occurs. (The reason is that a method invocation of this form does not specify a reference to an object that can serve as this within the instance method.)
• If the compile-time declaration for the method invocation is void, then the method invocation must be a top-level expression, that is, the Expression in an expression statement (§14.7) or in the ForInit or ForUpdate part of a for statement (§14.12), or a compile-time error occurs. (The reason is that such a method invocation produces no value and so must be used only in a situation where a value is not needed.)

• The name of the method.
• The class or interface that contains the compile-time declaration.
• The number of parameters and the types of the parameters, in order.
• The result type, or void, as declared in the compile-time declaration.
• The invocation mode, computed as follows:
  • If the compile-time declaration has the static modifier, then the invocation mode is static.
  • Otherwise, if the compile-time declaration has the private modifier, then the invocation mode is nonvirtual.
  • Otherwise, if the part of the method invocation before the left parenthesis is of the form super . Identifier, then the invocation mode is super.
  • Otherwise, if the compile-time declaration is in an interface, then the invocation mode is interface.
  • Otherwise, the invocation mode is virtual.

15.11.4 Runtime Evaluation of Method Invocation

15.11.4.1 Compute Target Reference (If Necessary)

• If the first production for MethodInvocation, which includes a MethodName, is involved, then there are three subcases:
  • If the MethodName is a simple name, that is, just an Identifier, then there are two subcases:
    • If the invocation mode is static, then there is no target reference.
    • Otherwise, the target reference is the value of this.
  • If the MethodName is a qualified name of the form TypeName . Identifier, then there is no target reference.
  • If the MethodName is a qualified name of the form FieldName . Identifier, then there are two subcases:
    • If the invocation mode is static, then there is no target reference.
    • Otherwise, the target reference is the value of the expression FieldName.
• If the second production for MethodInvocation, which includes a Primary, is involved, then there are two subcases:
  • If the invocation mode is static, then there is no target reference. The expression Primary is evaluated, but the result is then discarded.
  • Otherwise, the expression Primary is evaluated and the result is used as the target reference.

In either case, if the evaluation of the Primary expression completes abruptly, then no part of any argument expression appears to have been evaluated, and the method invocation completes abruptly for the same reason.

• If the third production for MethodInvocation, which includes the keyword super, is involved, then the target reference is the value of this.

15.11.4.2 Evaluate Arguments

15.11.4.3 Check Accessibility of Type and Method

A Java Virtual Machine must insure, as part of linkage, that the method m still exists in the type T. If this is not true, then a NoSuchMethodError (which is a subclass of IncompatibleClassChangeError) occurs. If the invocation mode is interface, then the virtual machine must also check that the target reference type still implements the specified interface. If the target reference type does not still implement the interface, then an IncompatibleClassChangeError occurs.

The virtual machine must also insure, during linkage, that the type T and the method m are accessible. For the type T:

• If T is in the same package as C, then T is accessible.
• If T is in a different package than C, and T is public, then T is accessible.

• If m is public, then m is accessible. (All members of interfaces are public (§9.2)).
• If m is protected, then m is accessible if and only if either T is in the same package as C, or C is T or a subclass of T.
• If m has default (package) access, then m is accessible if and only if T is in the same package as C.
• If m is private, then m is accessible if and only if and C is T.

15.11.4.4 Locate Method to Invoke

If the invocation mode is static, no target reference is needed and overriding is not allowed. Method m of class T is the one to be invoked.

Otherwise, an instance method is to be invoked and there is a target reference. If the target reference is null, a NullPointerException is thrown at this point. Otherwise, the target reference is said to refer to a target object and will be used as the value of the keyword this in the invoked method. The other four possibilities for the invocation mode are then considered.

If the invocation mode is nonvirtual, overriding is not allowed. Method m of class T is the one to be invoked.

Otherwise, the invocation mode is interface, virtual, or super, and overriding may occur. A dynamic method lookup is used. The dynamic lookup process starts from a class S, determined as follows:

• If the invocation mode is interface or virtual, then S is initially the actual run-time class R of the target object. If the target object is an array, R is the class Object. (Note that for invocation mode interface, R necessarily implements T; for invocation mode virtual, R is necessarily either T or a subclass of T.)
• If the invocation mode is super, then S is initially the superclass of the class C that contains the method invocation.

1. If class S contains a declaration for a method named m with the same descriptor (same number of parameters, the same parameter types, and the same return type) required by the method invocation as determined at compile time (§15.11.3), then this is the method to be invoked, and the procedure terminates. (We note that as part of the loading and linking process that the virtual machine checks that an overriding method is at least as accessible as the overridden method; an IncompatibleClassChangeError occurs if this is not the case.)
2. Otherwise, if S is not T, this same lookup procedure is performed using the superclass of S; whatever it comes up with is the result of this lookup.

We note that the dynamic lookup process, while described here explicitly, will often be implemented implicitly, for example as a side-effect of the construction and use of per-class method dispatch tables, or the construction of other per-class structures used for efficient dispatch.

15.11.4.5 Create Frame, Synchronize, Transfer Control

Now a new activation frame is created, containing the target reference (if any) and the argument values (if any), as well as enough space for the local variables and stack for the method to be invoked and any other bookkeeping information that may be required by the implementation (stack pointer, program counter, reference to previous activation frame, and the like). If there is not sufficient memory available to create such an activation frame, an OutOfMemoryError is thrown.

The newly created activation frame becomes the current activation frame. The effect of this is to assign the argument values to corresponding freshly created parameter variables of the method, and to make the target reference available as this, if there is a target reference.

If the method m is a native method but the necessary native, implementation-dependent binary code has not been loaded (§20.16.14, §20.16.13) or otherwise cannot be dynamically linked, then an UnsatisfiedLinkError is thrown.

If the method m is not synchronized, control is transferred to the body of the method m to be invoked.

If the method m is synchronized, then an object must be locked before the transfer of control. No further progress can be made until the current thread can obtain the lock. If there is a target reference, then the target must be locked; otherwise the Class object for class S, the class of the method m, must be locked. Control is then transferred to the body of the method m to be invoked. The object is automatically unlocked when execution of the body of the method has completed, whether normally or abruptly. The locking and unlocking behavior is exactly as if the body of the method were embedded in a synchronized statement (§14.17).

15.11.4.6 Implementation Note: Combining Frames

• Class C and class S have the same class loader (§20.14) and class S is not SecurityManager or a subclass of SecurityManager.
• Class S has no class loader (this fact indicates that it is a system class); class S is not SecurityManager or a subclass of SecurityManager; and method m is known not to call, directly or indirectly, any method of SecurityManager (§20.17) or any of its subclasses.

15.11.4.7 Example: Target Reference and Static Methods

class Test {
	static void mountain() {

		System.out.println("Monadnock");

	}

	static Test favorite(){
		System.out.print("Mount ");
		return null;
	}

	public static void main(String[] args) {
		favorite().mountain();
	}
}

Mount Monadnock

15.11.4.8 Example: Evaluation Order

So, for example, in:

class Test {
	public static void main(String[] args) {
		String s = "one";
		if (s.startsWith(s = "two"))
			System.out.println("oops");
	}
}

15.11.4.9 Example: Overriding

class Point {

	final int EDGE = 20;
	int x, y;

	void move(int dx, int dy) {
		x += dx; y += dy;
		if (Math.abs(x) >= EDGE || Math.abs(y) >= EDGE)
			clear();
	}

	void clear() {
		System.out.println("\tPoint clear");
		x = 0; y = 0;
	}
}

class ColoredPoint extends Point {
	int color;

	void clear() {
		System.out.println("\tColoredPoint clear");
		super.clear();
		color = 0;
	}
}

This method is then invoked whenever the target object for an invocation of clear is a ColoredPoint. Even the method move in Point invokes the clear method of class ColoredPoint when the class of this is ColoredPoint, as shown by the output of this test program:

class Test {
	public static void main(String[] args) {
		Point p = new Point();
		System.out.println("p.move(20,20):");
		p.move(20, 20);
		ColoredPoint cp = new ColoredPoint();
		System.out.println("cp.move(20,20):");
		cp.move(20, 20);
		p = new ColoredPoint();
		System.out.println("p.move(20,20), p colored:");
		p.move(20, 20);
	}
}

p.move(20,20):
	Point clear
cp.move(20,20):
	ColoredPoint clear
	Point clear
p.move(20,20), p colored:
	ColoredPoint clear
	Point clear

15.11.4.10 Example: Method Invocation using super

When accessing an instance variable, super means the same as a cast of this (§15.10.2), but this equivalence does not hold true for method invocation. This is demonstrated by the example:

class T1 {
	String s() { return "1"; }
}

class T2 extends T1 {
	String s() { return "2"; }
}

class T3 extends T2 {
	String s() { return "3"; }

	void test() {
		System.out.println("s()=\t\t"+s());
		System.out.println("super.s()=\t"+super.s());
		System.out.print("((T2)this).s()=\t");
			System.out.println(((T2)this).s());
		System.out.print("((T1)this).s()=\t");
			System.out.println(((T1)this).s());
	}
}

class Test {
	public static void main(String[] args) {
		T3 t3 = new T3();
		t3.test();
	}
}

s()=					3
super.s()=					2
((T2)this).s()=					3
((T1)this).s()=					3

15.12 Array Access Expressions

ArrayAccess:

	ExpressionName [ Expression ]

	PrimaryNoNewArray [ Expression ]

The type of the array reference expression must be an array type (call it T[], an array whose components are of type T) or a compile-time error results. Then the type of the array access expression is T.

The index expression undergoes unary numeric promotion (§5.6.1); the promoted type must be int.

The result of an array reference is a variable of type T, namely the variable within the array selected by the value of the index expression. This resulting variable, which is a component of the array, is never considered final, even if the array reference was obtained from a final variable.

15.12.1 Runtime Evaluation of Array Access

• First, the array reference expression is evaluated. If this evaluation completes abruptly, then the array access completes abruptly for the same reason and the index expression is not evaluated.
• Otherwise, the index expression is evaluated. If this evaluation completes abruptly, then the array access completes abruptly for the same reason.
• Otherwise, if the value of the array reference expression is null, then a NullPointerException is thrown.
• Otherwise, the value of the array reference expression indeed refers to an array. If the value of the index expression is less than zero, or greater than or equal to the array's length, then an IndexOutOfBoundsException is thrown.
• Otherwise, the result of the array reference is the variable of type T, within the array, selected by the value of the index expression. (Note that this resulting variable, which is a component of the array, is never considered final, even if the array reference expression is a final variable.)

15.12.2 Examples: Array Access Evaluation Order

Thus, the example:

class Test {
	public static void main(String[] args) {
		int[] a = { 11, 12, 13, 14 };
		int[] b = { 0, 1, 2, 3 };
		System.out.println(a[(a=b)[3]]);
	}
}

14

If evaluation of the expression to the left of the brackets completes abruptly, no part of the expression within the brackets will appear to have been evaluated. Thus, the example:

class Test {
	public static void main(String[] args) {
		int index = 1;
		try {
			skedaddle()[index=2]++;
		} catch (Exception e) {
			System.out.println(e + ", index=" + index);
		}
	}
	static int[] skedaddle() throws Exception {
		throw new Exception("Ciao");
	}
}

java.lang.Exception: Ciao, index=1

If the array reference expression produces null instead of a reference to an array, then a NullPointerException is thrown at run time, but only after all parts of the array reference expression have been evaluated and only if these evaluations completed normally. Thus, the example:

class Test {

	public static void main(String[] args) {
		int index = 1;
		try {
			nada()[index=2]++;
		} catch (Exception e) {
			System.out.println(e + ", index=" + index);
		}
	}
	static int[] nada() { return null; }
}

java.lang.NullPointerException, index=2

class Test {

	public static void main(String[] args) {
		int[] a = null;
		try {
			int i = a[vamoose()];
			System.out.println(i);
		} catch (Exception e) {
			System.out.println(e);
		}
	}

	static int vamoose() throws Exception {
		throw new Exception("Twenty-three skidoo!");
	}
}

java.lang.Exception: Twenty-three skidoo!

15.13 Postfix Expressions

PostfixExpression:

	Primary

	ExpressionName

	PostIncrementExpression

	PostDecrementExpression

15.13.1 Names

• If it is a simple name, that is, just an Identifier, then there are two cases:
  • If the Identifier occurs within the scope of a parameter or local variable named by that same Identifier, then the type of the ExpressionName is the declared type of the parameter or local variable; moreover, the value of the ExpressionName is a variable, namely, the parameter or local variable itself.
  • Otherwise, the ExpressionName is treated exactly as if it had been the field access expression (§15.10):
  this.Identifier
  • containing the keyword this (§15.7.2).
• Otherwise, if it is a qualified name of the form PackageName . Identifier, then a compile-time error occurs.
• Otherwise, if it is a qualified name of the form TypeName . Identifier, then it is refers to a static field of the class or interface named by the TypeName. A compile-time error occurs if TypeName does not name a class or interface. A compile-time error occurs if the class or interface named by TypeName does not contain an accessible static field named by the Identifier. The type of the ExpressionName is the declared type of the static field. The value of the ExpressionName is a variable, namely, the static field itself.
• Otherwise, it is a qualified name of the form Ename . Identifier, where Ename is itself an ExpressionName, and the ExpressionName is treated exactly as if it had been the field access expression (§15.10): (Ename).Identifier

containing a parenthesized expression (§15.7.3).

15.13.2 Postfix Increment Operator ++

PostIncrementExpression:

	PostfixExpression ++

At run time, if evaluation of the operand expression completes abruptly, then the postfix increment expression completes abruptly for the same reason and no incrementation occurs. Otherwise, the value 1 is added to the value of the variable and the sum is stored back into the variable. Before the addition, binary numeric promotion (§5.6.2) is performed on the value 1 and the value of the variable. If necessary, the sum is narrowed by a narrowing primitive conversion (§5.1.3) to the type of the variable before it is stored. The value of the postfix increment expression is the value of the variable before the new value is stored.

A variable that is declared final cannot be incremented, because when an access of a final variable is used as an expression, the result is a value, not a variable. Thus, it cannot be used as the operand of a postfix increment operator.

15.13.3 Postfix Decrement Operator --

PostDecrementExpression:

	PostfixExpression --

At run time, if evaluation of the operand expression completes abruptly, then the postfix decrement expression completes abruptly for the same reason and no decrementation occurs. Otherwise, the value 1 is subtracted from the value of the variable and the difference is stored back into the variable. Before the subtraction, binary numeric promotion (§5.6.2) is performed on the value 1 and the value of the variable. If necessary, the difference is narrowed by a narrowing primitive conversion (§5.1.3) to the type of the variable before it is stored. The value of the postfix decrement expression is the value of the variable before the new value is stored.

A variable that is declared final cannot be decremented, because when an access of a final variable is used as an expression, the result is a value, not a variable. Thus, it cannot be used as the operand of a postfix decrement operator.

15.14 Unary Operators

UnaryExpression:

	PreIncrementExpression

	PreDecrementExpression

	+ UnaryExpression

	- UnaryExpression

	UnaryExpressionNotPlusMinus

PreIncrementExpression:

	++ UnaryExpression

PreDecrementExpression:

	-- UnaryExpression

UnaryExpressionNotPlusMinus:

	PostfixExpression

	~ UnaryExpression

	! UnaryExpression

	CastExpression

CastExpression:

	( PrimitiveType ) UnaryExpression

	( ReferenceType ) UnaryExpressionNotPlusMinus

The first potential ambiguity would arise in expressions such as (p)+q, which looks, to a C or C++ programmer, as though it could be either be a cast to type p of a unary + operating on q, or a binary addition of two quantities p and q. In C and C++, the parser handles this problem by performing a limited amount of semantic analysis as it parses, so that it knows whether p is the name of a type or the name of a variable.

Java takes a different approach. The result of the + operator must be numeric, and all type names involved in casts on numeric values are known keywords. Thus, if p is a keyword naming a primitive type, then (p)+q can make sense only as a cast of a unary expression. However, if p is not a keyword naming a primitive type, then (p)+q can make sense only as a binary arithmetic operation. Similar remarks apply to the - operator. The grammar shown above splits CastExpression into two cases to make this distinction. The nonterminal UnaryExpression includes all unary operator, but the nonterminal UnaryExpressionNotPlusMinus excludes uses of all unary operators that could also be binary operators, which in Java are + and -.

The second potential ambiguity is that the expression (p)++ could, to a C or C++ programmer, appear to be either a postfix increment of a parenthesized expression or the beginning of a cast, for example, in (p)++q. As before, parsers for C and C++ know whether p is the name of a type or the name of a variable. But a parser using only one-token lookahead and no semantic analysis during the parse would not be able to tell, when ++ is the lookahead token, whether (p) should be considered a Primary expression or left alone for later consideration as part of a CastExpression.

In Java, the result of the ++ operator must be numeric, and all type names involved in casts on numeric values are known keywords. Thus, if p is a keyword naming a primitive type, then (p)++ can make sense only as a cast of a prefix increment expression, and there had better be an operand such as q following the ++. However, if p is not a keyword naming a primitive type, then (p)++ can make sense only as a postfix increment of p. Similar remarks apply to the -- operator. The nonterminal UnaryExpressionNotPlusMinus therefore also excludes uses of the prefix operators ++ and --.

15.14.1 Prefix Increment Operator ++

At run time, if evaluation of the operand expression completes abruptly, then the prefix increment expression completes abruptly for the same reason and no incrementation occurs. Otherwise, the value 1 is added to the value of the variable and the sum is stored back into the variable. Before the addition, binary numeric promotion (§5.6.2) is performed on the value 1 and the value of the variable. If necessary, the sum is narrowed by a narrowing primitive conversion (§5.1.3) to the type of the variable before it is stored. The value of the prefix increment expression is the value of the variable after the new value is stored.

A variable that is declared final cannot be incremented, because when an access of a final variable is used as an expression, the result is a value, not a variable. Thus, it cannot be used as the operand of a prefix increment operator.

15.14.2 Prefix Decrement Operator --

At run time, if evaluation of the operand expression completes abruptly, then the prefix decrement expression completes abruptly for the same reason and no decrementation occurs. Otherwise, the value 1 is subtracted from the value of the variable and the difference is stored back into the variable. Before the subtraction, binary numeric promotion (§5.6.2) is performed on the value 1 and the value of the variable. If necessary, the difference is narrowed by a narrowing primitive conversion (§5.1.3) to the type of the variable before it is stored. The value of the prefix decrement expression is the value of the variable after the new value is stored.

A variable that is declared final cannot be decremented, because when an access of a final variable is used as an expression, the result is a value, not a variable. Thus, it cannot be used as the operand of a prefix decrement operator.

15.14.3 Unary Plus Operator +

At run time, the value of the unary plus expression is the promoted value of the operand.

15.14.4 Unary Minus Operator -

At run time, the value of the unary plus expression is the arithmetic negation of the promoted value of the operand.

For integer values, negation is the same as subtraction from zero. Java uses two's-complement representation for integers, and the range of two's-complement values is not symmetric, so negation of the maximum negative int or long results in that same maximum negative number. Overflow occurs in this case, but no exception is thrown. For all integer values x, -x equals (~x)+1.

For floating-point values, negation is not the same as subtraction from zero, because if x is +0.0, then 0.0-x equals +0.0, but -x equals -0.0. Unary minus merely inverts the sign of a floating-point number. Special cases of interest:

• If the operand is NaN, the result is NaN (recall that NaN has no sign).
• If the operand is an infinity, the result is the infinity of opposite sign.
• If the operand is a zero, the result is the zero of opposite sign.

15.14.5 Bitwise Complement Operator ~

At run time, the value of the unary bitwise complement expression is the bitwise complement of the promoted value of the operand; note that, in all cases, ~x equals (-x)-1.

15.14.6 Logical Complement Operator !

At run time, the value of the unary logical complement expression is true if the operand value is false and false if the operand value is true.

15.15 Cast Expressions

CastExpression:

	( PrimitiveType Dimsopt ) UnaryExpression

	( ReferenceType ) UnaryExpressionNotPlusMinus

The type of a cast expression is the type whose name appears within the parentheses. (The parentheses and the type they contain are sometimes called the cast operator.) The result of a cast expression is not a variable, but a value, even if the result of the operand expression is a variable.

At run time, the operand value is converted by casting conversion (§5.4) to the type specified by the cast operator.

Not all casts are permitted by the Java language. Some casts result in an error at compile time. For example, a primitive value may not be cast to a reference type. Some casts can be proven, at compile time, always to be correct at run time. For example, it is always correct to convert a value of a class type to the type of its superclass; such a cast should require no special action at run time. Finally, some casts cannot be proven to be either always correct or always incorrect at compile time. Such casts require a test at run time. A ClassCastException is thrown if a cast is found at run time to be impermissible.

15.16 Multiplicative Operators

MultiplicativeExpression:

	UnaryExpression

	MultiplicativeExpression * UnaryExpression

	MultiplicativeExpression / UnaryExpression

	MultiplicativeExpression % UnaryExpression

15.16.1 Multiplication Operator *

If an integer multiplication overflows, then the result is the low-order bits of the mathematical product as represented in some sufficiently large two's-complement format. As a result, if overflow occurs, then the sign of the result may not be the same as the sign of the mathematical product of the two operand values.

The result of a floating-point multiplication is governed by the rules of IEEE 754 arithmetic:

• If either operand is NaN, the result is NaN.
• If the result is not NaN, the sign of the result is positive if both operands have the same sign, and negative if the operands have different signs.
• Multiplication of an infinity by a zero results in NaN.
• Multiplication of an infinity by a finite value results in a signed infinity. The sign is determined by the rule stated above.
• In the remaining cases, where neither an infinity or NaN is involved, the product is computed. If the magnitude of the product is too large to represent, we say the operation overflows. The result is then an infinity of appropriate sign. If the magnitude is too small to represent, we say the operation underflows; the result is then a zero of appropriate sign. Otherwise, the product is rounded to the nearest representable value using IEEE 754 round-to-nearest mode. The Java language requires support of gradual underflow as defined by IEEE 754 (§4.2.4).

15.16.2 Division Operator /

Integer division rounds toward 0. That is, the quotient produced for operands n and d that are integers after binary numeric promotion (§5.6.2) is an integer value q whose magnitude is as large as possible while satisfying ; moreover, q is positive when and n and d have the same sign, but q is negative when and n and d have opposite signs. There is one special case that does not satisfy this rule: if the dividend is the negative integer of largest possible magnitude for its type, and the divisor is -1, then integer overflow occurs and the result is equal to the dividend. Despite the overflow, no exception is thrown in this case. On the other hand, if the value of the divisor in an integer division is 0, then an ArithmeticException is thrown.

The result of a floating-point division is determined by the specification of IEEE arithmetic:

• If either operand is NaN, the result is NaN.
• If the result is not NaN, the sign of the result is positive if both operands have the same sign, negative if the operands have different signs.
• Division of an infinity by an infinity results in NaN.
• Division of an infinity by a finite value results in a signed infinity. The sign is determined by the rule stated above.
• Division of a finite value by an infinity results in a signed zero. The sign is determined by the rule stated above.
• Division of a zero by a zero results in NaN; division of zero by any other finite value results in a signed zero. The sign is determined by the rule stated above.
• Division of a nonzero finite value by a zero results in a signed infinity. The sign is determined by the rule stated above.
• In the remaining cases, where neither an infinity, nor a zero, nor NaN is involved, the quotient is computed. If the magnitude of the quotient is too large to represent, we say the operation overflows; the result is then an infinity of appropriate sign. If the magnitude is too small to represent, we say the operation underflows and the result is then a zero of appropriate sign. Otherwise, the quotient is rounded to the nearest representable value using IEEE 754 round-to-nearest mode. The Java language requires support of gradual underflow as defined by IEEE 754 (§4.2.4).

15.16.3 Remainder Operator %

In C and C++, the remainder operator accepts only integral operands, but in Java, it also accepts floating-point operands.

The remainder operation for operands that are integers after binary numeric promotion (§5.6.2) produces a result value such that (a/b)*b+(a%b) is equal to a. This identity holds even in the special case that the dividend is the negative integer of largest possible magnitude for its type and the divisor is -1 (the remainder is 0). It follows from this rule that the result of the remainder operation can be negative only if the dividend is negative, and can be positive only if the dividend is positive; moreover, the magnitude of the result is always less than the magnitude of the divisor. If the value of the divisor for an integer remainder operator is 0, then an ArithmeticException is thrown.

Examples:

5%3 produces 2							(note that 5/3 produces 1)
5%(-3) produces 2							(note that 5/(-3) produces -1)
(-5)%3 produces -2							(note that (-5)/3 produces -1)
(-5)%(-3) produces -2							(note that (-5)/(-3) produces 1)

The result of a Java floating-point remainder operation is determined by the rules of IEEE arithmetic:

• If either operand is NaN, the result is NaN.
• If the result is not NaN, the sign of the result equals the sign of the dividend.
• If the dividend is an infinity, or the divisor is a zero, or both, the result is NaN.
• If the dividend is finite and the divisor is an infinity, the result equals the dividend.
• If the dividend is a zero and the divisor is finite, the result equals the dividend.
• In the remaining cases, where neither an infinity, nor a zero, nor NaN is involved, the floating-point remainder r from the division of a dividend n by a divisor d is defined by the mathematical relation where q is an integer that is negative only if is negative and positive only if is positive, and whose magnitude is as large as possible without exceeding the magnitude of the true mathematical quotient of n and d.

Examples:

5.0%3.0 produces 2.0
5.0%(-3.0) produces 2.0
(-5.0)%3.0 produces -2.0
(-5.0)%(-3.0) produces -2.0

15.17 Additive Operators

AdditiveExpression:

	MultiplicativeExpression

	AdditiveExpression + MultiplicativeExpression

	AdditiveExpression - MultiplicativeExpression

Otherwise, the type of each of the operands of the + operator must be a primitive numeric type, or a compile-time error occurs.

In every case, the type of each of the operands of the binary - operator must be a primitive numeric type, or a compile-time error occurs.

15.17.1 String Concatenation Operator +

15.17.1.1 String Conversion

A value x of primitive type T is first converted to a reference value as if by giving it as an argument to an appropriate class instance creation expression:

• If T is boolean, then use new Boolean(x) (§20.4).
• If T is char, then use new Character(x) (§20.5).
• If T is byte, short, or int, then use new Integer(x) (§20.7).
• If T is long, then use new Long(x) (§20.8).
• If T is float, then use new Float(x) (§20.9).
• If T is double, then use new Double(x) (§20.10).

Now only reference values need to be considered. If the reference is null, it is converted to the string "null" (four ASCII characters n, u, l, l). Otherwise, the conversion is performed as if by an invocation of the toString method of the referenced object with no arguments; but if the result of invoking the toString method is null, then the string "null" is used instead. The toString method (§20.1.2) is defined by the primordial class Object (§20.1); many classes override it, notably Boolean, Character, Integer, Long, Float, Double, and String.

15.17.1.2 Optimization of String Concatenation

For primitive objects, an implementation may also optimize away the creation of a wrapper object by converting directly from a primitive type to a string.

15.17.1.3 Examples of String Concatenation

"The square root of 2 is " + Math.sqrt(2)

"The square root of 2 is 1.4142135623730952"

a + b + c

(a + b) + c

1 + 2 + " fiddlers"

"3 fiddlers"

"fiddlers " + 1 + 2

"fiddlers 12"

class Bottles {

	static void printSong(Object stuff, int n) {
		String plural = "s";
		loop: while (true) {
			System.out.println(n + " bottle" + plural
				+ " of " + stuff + " on the wall,");
			System.out.println(n + " bottle" + plural
				+ " of " + stuff + ";");
			System.out.println("You take one down "
				+ "and pass it around:");
			--n;
			plural = (n == 1) ? "" : "s";
			if (n == 0)
				break loop;
			System.out.println(n + " bottle" + plural
				+ " of " + stuff + " on the wall!");
			System.out.println();
		}
		System.out.println("No bottles of " +
								stuff + " on the wall!");
	}

}

3 bottles of slime on the wall,
3 bottles of slime;
You take one down and pass it around:
2 bottles of slime on the wall!

2 bottles of slime on the wall,
2 bottles of slime;
You take one down and pass it around:
1 bottle of slime on the wall!

1 bottle of slime on the wall,
1 bottle of slime;
You take one down and pass it around:
No bottles of slime on the wall!

"You take one down and pass it around:"

15.17.2 Additive Operators (+ and -) for Numeric Types

Binary numeric promotion is performed on the operands (§5.6.2). The type of an additive expression on numeric operands is the promoted type of its operands. If this promoted type is int or long, then integer arithmetic is performed; if this promoted type is float or double, then floating-point arithmetic is performed.

Addition is a commutative operation if the operand expressions have no side effects. Integer addition is associative when the operands are all of the same type, but floating-point addition is not associative.

If an integer addition overflows, then the result is the low-order bits of the mathematical sum as represented in some sufficiently large two's-complement format. If overflow occurs, then the sign of the result is not the same as the sign of the mathematical sum of the two operand values.

The result of a floating-point addition is determined using the following rules of IEEE arithmetic:

• If either operand is NaN, the result is NaN.
• The sum of two infinities of opposite sign is NaN.
• The sum of two infinities of the same sign is the infinity of that sign.
• The sum of an infinity and a finite value is equal to the infinite operand.
• The sum of two zeros of opposite sign is positive zero.
• The sum of two zeros of the same sign is the zero of that sign.
• The sum of a zero and a nonzero finite value is equal to the nonzero operand.
• The sum of two nonzero finite values of the same magnitude and opposite sign is positive zero.
• In the remaining cases, where neither an infinity, nor a zero, nor NaN is involved, and the operands have the same sign or have different magnitudes, the sum is computed. If the magnitude of the sum is too large to represent, we say the operation overflows; the result is then an infinity of appropriate sign. If the magnitude is too small to represent, we say the operation underflows; the result is then a zero of appropriate sign. Otherwise, the sum is rounded to the nearest representable value using IEEE 754 round-to-nearest mode. The Java language requires support of gradual underflow as defined by IEEE 754 (§4.2.4).

Despite the fact that overflow, underflow, or loss of information may occur, evaluation of a numeric additive operator never throws a run-time exception.

15.18 Shift Operators

ShiftExpression:

	AdditiveExpression

	ShiftExpression << AdditiveExpression

	ShiftExpression >> AdditiveExpression

	ShiftExpression >>> AdditiveExpression

If the promoted type of the left-hand operand is int, only the five lowest-order bits of the right-hand operand are used as the shift distance. It is as if the right-hand operand were subjected to a bitwise logical AND operator & (§15.21.1) with the mask value 0x1f. The shift distance actually used is therefore always in the range 0 to 31, inclusive.

If the promoted type of the left-hand operand is long, then only the six lowest-order bits of the right-hand operand are used as the shift distance. It is as if the right-hand operand were subjected to a bitwise logical AND operator & (§15.21.1) with the mask value 0x3f. The shift distance actually used is therefore always in the range 0 to 63, inclusive.

At run time, shift operations are performed on the two's complement integer representation of the value of the left operand.

The value of n<<s is n left-shifted s bit positions; this is equivalent (even if overflow occurs) to multiplication by two to the power s.

The value of n>>s is n right-shifted s bit positions with sign-extension. The resulting value is . For nonnegative values of n, this is equivalent to truncating integer division, as computed by the integer division operator /, by two to the power s.

The value of n>>>s is n right-shifted s bit positions with zero-extension. If n is positive, then the result is the same as that of n>>s; if n is negative, the result is equal to that of the expression (n>>s)+(2<<~s) if the type of the left-hand operand is int, and to the result of the expression (n>>s)+(2L<<~s) if the type of the left-hand operand is long. The added term (2<<~s) or (2L<<~s) cancels out the propagated sign bit. (Note that, because of the implicit masking of the right-hand operand of a shift operator, ~s as a shift distance is equivalent to 31-s when shifting an int value and to 63-s when shifting a long value.)

15.19 Relational Operators

RelationalExpression:

	ShiftExpression

	RelationalExpression < ShiftExpression

	RelationalExpression > ShiftExpression

	RelationalExpression <= ShiftExpression

	RelationalExpression >= ShiftExpression

	RelationalExpression instanceof ReferenceType

15.19.1 Numerical Comparison Operators <, <=, >, and >=

The result of a floating-point comparison, as determined by the specification of the IEEE 754 standard, is:

• If either operand is NaN, then the result is false.
• All values other than NaN are ordered, with negative infinity less than all finite values, and positive infinity greater than all finite values.
• Positive zero and negative zero are considered equal. Therefore, -0.0<0.0 is false, for example, but -0.0<=0.0 is true. (Note, however, that the methods Math.min (§20.11.27, §20.11.28) and Math.max (§20.11.31, §20.11.32) treat negative zero as being strictly smaller than positive zero.)

• The value produced by the < operator is true if the value of the left-hand operand is less than the value of the right-hand operand, and otherwise is false.
• The value produced by the <= operator is true if the value of the left-hand operand is less than or equal to the value of the right-hand operand, and otherwise is false.
• The value produced by the > operator is true if the value of the left-hand operand is greater than the value of the right-hand operand, and otherwise is false.
• The value produced by the >= operator is true if the value of the left-hand operand is greater than or equal to the value of the right-hand operand, and otherwise is false.

15.19.2 Type Comparison Operator instanceof

At run time, the result of the instanceof operator is true if the value of the RelationalExpression is not null and the reference could be cast (§15.15) to the ReferenceType without raising a ClassCastException. Otherwise the result is false.

If a cast of the RelationalExpression to the ReferenceType would be rejected as a compile-time error, then the instanceof relational expression likewise produces a compile-time error. In such a situation, the result of the instanceof expression could never be true.

Consider the example program:

class Point { int x, y; }
class Element { int atomicNumber; }
class Test {
	public static void main(String[] args) {
		Point p = new Point();
		Element e = new Element();
		if (e instanceof Point) {											// compile-time error
			System.out.println("I get your point!");
			p = (Point)e;										// compile-time error
		}
	}
}

class Point extends Element { int x, y; }

15.20 Equality Operators

EqualityExpression:

	RelationalExpression

	EqualityExpression == RelationalExpression

	EqualityExpression != RelationalExpression

The equality operators may be used to compare two operands of numeric type, or two operands of type boolean, or two operands that are each of either reference type or the null type. All other cases result in a compile-time error. The type of an equality expression is always boolean.

In all cases, a!=b produces the same result as !(a==b). The equality operators are commutative if the operand expressions have no side effects.

15.20.1 Numerical Equality Operators == and !=

Floating-point equality testing is performed in accordance with the rules of the IEEE 754 standard:

• If either operand is NaN, then the result of == is false but the result of != is true. Indeed, the test x!=x is true if and only if the value of x is NaN. (The methods Float.isNaN (§20.9.19) and Double.isNaN (§20.10.17) may also be used to test whether a value is NaN.)
• Positive zero and negative zero are considered equal. Therefore, -0.0==0.0 is true, for example.
• Otherwise, two distinct floating-point values are considered unequal by the equality operators. In particular, there is one value representing positive infinity and one value representing negative infinity; each compares equal only to itself, and each compares unequal to all other values.

• The value produced by the == operator is true if the value of the left-hand operand is equal to the value of the right-hand operand; otherwise, the result is false.
• The value produced by the != operator is true if the value of the left-hand operand is not equal to the value of the right-hand operand; otherwise, the result is false.

15.20.2 Boolean Equality Operators == and !=

The result of == is true if the operands are both true or both false; otherwise, the result is false.

The result of != is false if the operands are both true or both false; otherwise, the result is true. Thus != behaves the same as ^ (§15.21.2) when applied to boolean operands.

15.20.3 Reference Equality Operators == and !=

A compile-time error occurs if it is impossible to convert the type of either operand to the type of the other by a casting conversion (§5.4). The run-time values of the two operands would necessarily be unequal.

At run time, the result of == is true if the operand values are both null or both refer to the same object or array; otherwise, the result is false.

The result of != is false if the operand values are both null or both refer to the same object or array; otherwise, the result is true.

While == may be used to compare references of type String, such an equality test determines whether or not the two operands refer to the same String object. The result is false if the operands are distinct String objects, even if they contain the same sequence of characters. The contents of two strings s and t can be tested for equality by the method invocation s.equals(t) (§20.12.9). See also §3.10.5 and §20.12.47.

15.21 Bitwise and Logical Operators

AndExpression:

	EqualityExpression

	AndExpression & EqualityExpression

ExclusiveOrExpression:

	AndExpression

	ExclusiveOrExpression ^ AndExpression

InclusiveOrExpression:

	ExclusiveOrExpression

	InclusiveOrExpression | ExclusiveOrExpression

15.21.1 Integer Bitwise Operators &, ^, and |

For &, the result value is the bitwise AND of the operand values.

For ^, the result value is the bitwise exclusive OR of the operand values.

For |, the result value is the bitwise inclusive OR of the operand values.

For example, the result of the expression 0xff00 & 0xf0f0 is 0xf000. The result of 0xff00 ^ 0xf0f0 is 0x0ff0.The result of 0xff00 | 0xf0f0 is 0xfff0.

15.21.2 Boolean Logical Operators &, ^, and |

For &, the result value is true if both operand values are true; otherwise, the result is false.

For ^, the result value is true if the operand values are different; otherwise, the result is false.

For |, the result value is false if both operand values are false; otherwise, the result is true.

15.22 Conditional-And Operator &&

ConditionalAndExpression:

	InclusiveOrExpression

	ConditionalAndExpression && InclusiveOrExpression

At run time, the left-hand operand expression is evaluated first; if its value is false, the value of the conditional-and expression is false and the right-hand operand expression is not evaluated. If the value of the left-hand operand is true, then the right-hand expression is evaluated and its value becomes the value of the conditional-and expression. Thus, && computes the same result as & on boolean operands. It differs only in that the right-hand operand expression is evaluated conditionally rather than always.

15.23 Conditional-Or Operator ||

ConditionalOrExpression:

	ConditionalAndExpression

	ConditionalOrExpression || ConditionalAndExpression

At run time, the left-hand operand expression is evaluated first; if its value is true, the value of the conditional-or expression is true and the right-hand operand expression is not evaluated. If the value of the left-hand operand is false, then the right-hand expression is evaluated and its value becomes the value of the conditional-or expression. Thus, || computes the same result as | on boolean operands. It differs only in that the right-hand operand expression is evaluated conditionally rather than always.

15.24 Conditional Operator ? :

The conditional operator is syntactically right-associative (it groups right-to-left), so that a?b:c?d:e?f:g means the same as a?b:(c?d:(e?f:g)).

ConditionalExpression:

	ConditionalOrExpression

	ConditionalOrExpression ? Expression : ConditionalExpression

The first expression must be of type boolean, or a compile-time error occurs.

The conditional operator may be used to choose between second and third operands of numeric type, or second and third operands of type boolean, or second and third operands that are each of either reference type or the null type. All other cases result in a compile-time error.

Note that it is not permitted for either the second or the third operand expression to be an invocation of a void method. In fact, it is not permitted for a conditional expression to appear in any context where an invocation of a void method could appear (§14.7).

The type of a conditional expression is determined as follows:

• If the second and third operands have the same type (which may be the null type), then that is the type of the conditional expression.
• Otherwise, if the second and third operands have numeric type, then there are several cases:
  • If one of the operands is of type byte and the other is of type short, then the type of the conditional expression is short.
  • If one of the operands is of type T where T is byte, short, or char, and the other operand is a constant expression of type int whose value is representable in type T, then the type of the conditional expression is T.
  • Otherwise, binary numeric promotion (§5.6.2) is applied to the operand types, and the type of the conditional expression is the promoted type of the second and third operands.
• If one of the second and third operands is of the null type and the type of the other is a reference type, then the type of the conditional expression is that reference type.
• If the second and third operands are of different reference types, then it must be possible to convert one of the types to the other type (call this latter type T) by assignment conversion (§5.2); the type of the conditional expression is T. It is a compile-time error if neither type is assignment compatible with the other type.

• If the value of the first operand is true, then the second operand expression is chosen.
• If the value of the first operand is false, then the third operand expression is chosen.

15.25 Assignment Operators

AssignmentExpression:

	ConditionalExpression

	Assignment

Assignment:

	LeftHandSide AssignmentOperator AssignmentExpression

LeftHandSide:

	ExpressionName

	FieldAccess

	ArrayAccess

AssignmentOperator: one of

	= *= /= %= += -= <<= >>= >>>= &= ^= |=

At run time, the result of the assignment expression is the value of the variable after the assignment has occurred. The result of an assignment expression is not itself a variable.

A variable that is declared final cannot be assigned to, because when an access of a final variable is used as an expression, the result is a value, not a variable, and so it cannot be used as the operand of an assignment operator.

15.25.1 Simple Assignment Operator =

At run time, the expression is evaluated in one of two ways. If the left-hand operand expression is not an array access expression, then three steps are required:

• First, the left-hand operand is evaluated to produce a variable. If this evaluation completes abruptly, then the assignment expression completes abruptly for the same reason; the right-hand operand is not evaluated and no assignment occurs.
• Otherwise, the right-hand operand is evaluated. If this evaluation completes abruptly, then the assignment expression completes abruptly for the same reason and no assignment occurs.
• Otherwise, the value of the right-hand operand is converted to the type of the left-hand variable and the result of the conversion is stored into the variable.

• First, the array reference subexpression of the left-hand operand array access expression is evaluated. If this evaluation completes abruptly, then the assignment expression completes abruptly for the same reason; the index subexpression (of the left-hand operand array access expression) and the right-hand operand are not evaluated and no assignment occurs.
• Otherwise, the index subexpression of the left-hand operand array access expression is evaluated. If this evaluation completes abruptly, then the assignment expression completes abruptly for the same reason and the right-hand operand is not evaluated and no assignment occurs.
• Otherwise, the right-hand operand is evaluated. If this evaluation completes abruptly, then the assignment expression completes abruptly for the same reason and no assignment occurs.
• Otherwise, if the value of the array reference subexpression is null, then no assignment occurs and a NullPointerException is thrown.
• Otherwise, the value of the array reference subexpression indeed refers to an array. If the value of the index subexpression is less than zero, or greater than or equal to the length of the array, then no assignment occurs and an IndexOutOfBoundsException is thrown.
• Otherwise, the value of the index subexpression is used to select a component of the array referred to by the value of the array reference subexpression. This component is a variable; call its type SC. Also, let TC be the type of the left-hand operand of the assignment operator as determined at compile time.
  • If TC is a primitive type, then SC is necessarily the same as TC. The value of the right-hand operand is converted to a value of type TC and stored into the selected array component.
  • If T is a reference type, then SC may not be the same as T, but rather a type that extends or implements TC. Let RC be the class of the object referred to by the value of the right-hand operand at run time.
  • The compiler may be able to prove at compile time that the array component will be of type TC exactly (for example, TC might be final). But if the compiler cannot prove at compile time that the array component will be of type TC exactly, then a check must be performed at run time to ensure that the class RC is assignment compatible (§5.2) with the actual type SC of the array component. This check is similar to a narrowing cast (§5.4, §15.15), except that if the check fails, an ArrayStoreException is thrown rather than a ClassCastException. Therefore:
    • If class RC is not assignable to type SC, then no assignment occurs and an ArrayStoreException is thrown.
    • Otherwise, the reference value of the right-hand operand is stored into the selected array component.

class ArrayReferenceThrow extends RuntimeException { }


class IndexThrow extends RuntimeException { }


class RightHandSideThrow extends RuntimeException { }

class IllustrateSimpleArrayAssignment {

	static Object[] objects = { new Object(), new Object() };


	static Thread[] threads = { new Thread(), new Thread() };


	static Object[] arrayThrow() {
		throw new ArrayReferenceThrow();
	}


	static int indexThrow() { throw new IndexThrow(); }


	static Thread rightThrow() {
		throw new RightHandSideThrow();
	}


	static String name(Object q) {
		String sq = q.getClass().getName();
		int k = sq.lastIndexOf('.');
		return (k < 0) ? sq : sq.substring(k+1);
	}


	static void testFour(Object[] x, int j, Object y) {
		String sx = x == null ? "null" : name(x[0]) + "s";
		String sy = name(y);
		System.out.println();
		try {
			System.out.print(sx + "[throw]=throw => ");
			x[indexThrow()] = rightThrow();
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
		try {
			System.out.print(sx + "[throw]=" + sy + " => ");
			x[indexThrow()] = y;
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
		try {
			System.out.print(sx + "[" + j + "]=throw => ");
			x[j] = rightThrow();
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
		try {
			System.out.print(sx + "[" + j + "]=" + sy + " => ");
			x[j] = y;
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
	}


	public static void main(String[] args) {
		try {
			System.out.print("throw[throw]=throw => ");
			arrayThrow()[indexThrow()] = rightThrow();
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
		try {
			System.out.print("throw[throw]=Thread => ");
			arrayThrow()[indexThrow()] = new Thread();
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
		try {
			System.out.print("throw[1]=throw => ");
			arrayThrow()[1] = rightThrow();
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
		try {
			System.out.print("throw[1]=Thread => ");
			arrayThrow()[1] = new Thread();
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }

		testFour(null, 1, new StringBuffer());
		testFour(null, 1, new StringBuffer());
		testFour(null, 9, new Thread());
		testFour(null, 9, new Thread());
		testFour(objects, 1, new StringBuffer());
		testFour(objects, 1, new Thread());
		testFour(objects, 9, new StringBuffer());
		testFour(objects, 9, new Thread());
		testFour(threads, 1, new StringBuffer());
		testFour(threads, 1, new Thread());
		testFour(threads, 9, new StringBuffer());
		testFour(threads, 9, new Thread());
	}

}

throw[throw]=throw => ArrayReferenceThrow
throw[throw]=Thread => ArrayReferenceThrow
throw[1]=throw => ArrayReferenceThrow
throw[1]=Thread => ArrayReferenceThrow


null[throw]=throw => IndexThrow
null[throw]=StringBuffer => IndexThrow
null[1]=throw => RightHandSideThrow
null[1]=StringBuffer => NullPointerException


null[throw]=throw => IndexThrow
null[throw]=StringBuffer => IndexThrow
null[1]=throw => RightHandSideThrow
null[1]=StringBuffer => NullPointerException


null[throw]=throw => IndexThrow
null[throw]=Thread => IndexThrow
null[9]=throw => RightHandSideThrow
null[9]=Thread => NullPointerException


null[throw]=throw => IndexThrow
null[throw]=Thread => IndexThrow
null[9]=throw => RightHandSideThrow
null[9]=Thread => NullPointerException


Objects[throw]=throw => IndexThrow
Objects[throw]=StringBuffer => IndexThrow
Objects[1]=throw => RightHandSideThrow
Objects[1]=StringBuffer => Okay!


Objects[throw]=throw => IndexThrow
Objects[throw]=Thread => IndexThrow
Objects[1]=throw => RightHandSideThrow
Objects[1]=Thread => Okay!


Objects[throw]=throw => IndexThrow
Objects[throw]=StringBuffer => IndexThrow
Objects[9]=throw => RightHandSideThrow
Objects[9]=StringBuffer => IndexOutOfBoundsException


Objects[throw]=throw => IndexThrow
Objects[throw]=Thread => IndexThrow
Objects[9]=throw => RightHandSideThrow
Objects[9]=Thread => IndexOutOfBoundsException


Threads[throw]=throw => IndexThrow
Threads[throw]=StringBuffer => IndexThrow
Threads[1]=throw => RightHandSideThrow
Threads[1]=StringBuffer => ArrayStoreException


Threads[throw]=throw => IndexThrow
Threads[throw]=Thread => IndexThrow
Threads[1]=throw => RightHandSideThrow
Threads[1]=Thread => Okay!


Threads[throw]=throw => IndexThrow
Threads[throw]=StringBuffer => IndexThrow
Threads[9]=throw => RightHandSideThrow
Threads[9]=StringBuffer => IndexOutOfBoundsException


Threads[throw]=throw => IndexThrow
Threads[throw]=Thread => IndexThrow
Threads[9]=throw => RightHandSideThrow
Threads[9]=Thread => IndexOutOfBoundsException

Threads[1]=StringBuffer => ArrayStoreException

15.25.2 Compound Assignment Operators

A compound assignment expression of the form E1 op= E2 is equivalent to E1 = (T)((E1) op (E2)), where T is the type of E1, except that E1 is evaluated only once. Note that the implied cast to type T may be either an identity conversion (§5.1.1) or a narrowing primitive conversion (§5.1.3). For example, the following code is correct:

short x = 3;
x += 4.6;

short x = 3;
x = (short)(x + 4.6);

• First, the left-hand operand is evaluated to produce a variable. If this evaluation completes abruptly, then the assignment expression completes abruptly for the same reason; the right-hand operand is not evaluated and no assignment occurs.
• Otherwise, the value of the left-hand operand is saved and then the right-hand operand is evaluated. If this evaluation completes abruptly, then the assignment expression completes abruptly for the same reason and no assignment occurs.
• Otherwise, the saved value of the left-hand variable and the value of the right-hand operand are used to perform the binary operation indicated by the compound assignment operator. If this operation completes abruptly (the only possibility is an integer division by zero-see §15.16.2), then the assignment expression completes abruptly for the same reason and no assignment occurs.
• Otherwise, the result of the binary operation is converted to the type of the left-hand variable and the result of the conversion is stored into the variable.

• First, the array reference subexpression of the left-hand operand array access expression is evaluated. If this evaluation completes abruptly, then the assignment expression completes abruptly for the same reason; the index subexpression (of the left-hand operand array access expression) and the right-hand operand are not evaluated and no assignment occurs.
• Otherwise, the index subexpression of the left-hand operand array access expression is evaluated. If this evaluation completes abruptly, then the assignment expression completes abruptly for the same reason and the right-hand operand is not evaluated and no assignment occurs.
• Otherwise, if the value of the array reference subexpression is null, then no assignment occurs and a NullPointerException is thrown.
• Otherwise, the value of the array reference subexpression indeed refers to an array. If the value of the index subexpression is less than zero, or greater than or equal to the length of the array, then no assignment occurs and an IndexOutOfBoundsException is thrown.
• Otherwise, the value of the index subexpression is used to select a component of the array referred to by the value of the array reference subexpression. The value of this component is saved and then the right-hand operand is evaluated. If this evaluation completes abruptly, then the assignment expression completes abruptly for the same reason and no assignment occurs. (For a simple assignment operator, the evaluation of the right-hand operand occurs before the checks of the array reference subexpression and the index subexpression, but for a compound assignment operator, the evaluation of the right-hand operand occurs after these checks.)
• Otherwise, consider the array component selected in the previous step, whose value was saved. This component is a variable; call its type S. Also, let T be the type of the left-hand operand of the assignment operator as determined at compile time.
  • If T is a primitive type, then S is necessarily the same as T.
    • The saved value of the array component and the value of the right-hand operand are used to perform the binary operation indicated by the compound assignment operator. If this operation completes abruptly (the only possibility is an integer division by zero-see §15.16.2), then the assignment expression completes abruptly for the same reason and no assignment occurs.
    • Otherwise, the result of the binary operation is converted to the type of the array component and the result of the conversion is stored into the array component.
  • If T is a reference type, then it must be String. Because class String is a final class, S must also be String. Therefore the run-time check that is sometimes required for the simple assignment operator is never required for a compound assignment operator.
    • The saved value of the array component and the value of the right-hand operand are used to perform the binary operation (string concatenation) indicated by the compound assignment operator (which is necessarily +=). If this operation completes abruptly, then the assignment expression completes abruptly for the same reason and no assignment occurs.
    • Otherwise, the String result of the binary operation is stored into the array component.

class ArrayReferenceThrow extends RuntimeException { }


class IndexThrow extends RuntimeException { }


class RightHandSideThrow extends RuntimeException { }

class IllustrateCompoundArrayAssignment {

	static String[] strings = { "Simon", "Garfunkel" };


	static double[] doubles = { Math.E, Math.PI };

	static String[] stringsThrow() {
		throw new ArrayReferenceThrow();
	}


	static double[] doublesThrow() {
		throw new ArrayReferenceThrow();
	}


	static int indexThrow() { throw new IndexThrow(); }


	static String stringThrow() {
		throw new RightHandSideThrow();
	}


	static double doubleThrow() {
		throw new RightHandSideThrow();
	}


	static String name(Object q) {
		String sq = q.getClass().getName();
		int k = sq.lastIndexOf('.');
		return (k < 0) ? sq : sq.substring(k+1);
	}


	static void testEight(String[] x, double[] z, int j) {
		String sx = (x == null) ? "null" : "Strings";
		String sz = (z == null) ? "null" : "doubles";
		System.out.println();
		try {
			System.out.print(sx + "[throw]+=throw => ");
			x[indexThrow()] += stringThrow();
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
		try {
			System.out.print(sz + "[throw]+=throw => ");
			z[indexThrow()] += doubleThrow();
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }

		try {
			System.out.print(sx + "[throw]+=\"heh\" => ");
			x[indexThrow()] += "heh";
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
		try {
			System.out.print(sz + "[throw]+=12345 => ");
			z[indexThrow()] += 12345;
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
		try {
			System.out.print(sx + "[" + j + "]+=throw => ");
			x[j] += stringThrow();
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
		try {
			System.out.print(sz + "[" + j + "]+=throw => ");
			z[j] += doubleThrow();
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
		try {
			System.out.print(sx + "[" + j + "]+=\"heh\" => ");
			x[j] += "heh";
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
		try {
			System.out.print(sz + "[" + j + "]+=12345 => ");
			z[j] += 12345;
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
	}


	public static void main(String[] args) {
		try {
			System.out.print("throw[throw]+=throw => ");
			stringsThrow()[indexThrow()] += stringThrow();
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
		try {
			System.out.print("throw[throw]+=throw => ");
			doublesThrow()[indexThrow()] += doubleThrow();
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
		try {
			System.out.print("throw[throw]+=\"heh\" => ");
			stringsThrow()[indexThrow()] += "heh";
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }

		try {
			System.out.print("throw[throw]+=12345 => ");
			doublesThrow()[indexThrow()] += 12345;
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
		try {
			System.out.print("throw[1]+=throw => ");
			stringsThrow()[1] += stringThrow();
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
		try {
			System.out.print("throw[1]+=throw => ");
			doublesThrow()[1] += doubleThrow();
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
		try {
			System.out.print("throw[1]+=\"heh\" => ");
			stringsThrow()[1] += "heh";
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
		try {
			System.out.print("throw[1]+=12345 => ");
			doublesThrow()[1] += 12345;
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }

		testEight(null, null, 1);
		testEight(null, null, 9);
		testEight(strings, doubles, 1);
		testEight(strings, doubles, 9);
	}

}

throw[throw]+=throw => ArrayReferenceThrow
throw[throw]+=throw => ArrayReferenceThrow
throw[throw]+="heh" => ArrayReferenceThrow
throw[throw]+=12345 => ArrayReferenceThrow
throw[1]+=throw => ArrayReferenceThrow
throw[1]+=throw => ArrayReferenceThrow
throw[1]+="heh" => ArrayReferenceThrow
throw[1]+=12345 => ArrayReferenceThrow


null[throw]+=throw => IndexThrow
null[throw]+=throw => IndexThrow
null[throw]+="heh" => IndexThrow
null[throw]+=12345 => IndexThrow
null[1]+=throw => NullPointerException
null[1]+=throw => NullPointerException
null[1]+="heh" => NullPointerException
null[1]+=12345 => NullPointerException


null[throw]+=throw => IndexThrow
null[throw]+=throw => IndexThrow
null[throw]+="heh" => IndexThrow
null[throw]+=12345 => IndexThrow
null[9]+=throw => NullPointerException
null[9]+=throw => NullPointerException
null[9]+="heh" => NullPointerException
null[9]+=12345 => NullPointerException


Strings[throw]+=throw => IndexThrow
doubles[throw]+=throw => IndexThrow
Strings[throw]+="heh" => IndexThrow
doubles[throw]+=12345 => IndexThrow
Strings[1]+=throw => RightHandSideThrow
doubles[1]+=throw => RightHandSideThrow
Strings[1]+="heh" => Okay!
doubles[1]+=12345 => Okay!


Strings[throw]+=throw => IndexThrow
doubles[throw]+=throw => IndexThrow
Strings[throw]+="heh" => IndexThrow
doubles[throw]+=12345 => IndexThrow
Strings[9]+=throw => IndexOutOfBoundsException
doubles[9]+=throw => IndexOutOfBoundsException
Strings[9]+="heh" => IndexOutOfBoundsException
doubles[9]+=12345 => IndexOutOfBoundsException

Strings[1]+=throw => RightHandSideThrow
doubles[1]+=throw => RightHandSideThrow

The following program illustrates the fact that the value of the left-hand side of a compound assignment is saved before the right-hand side is evaluated:

class Test {
	public static void main(String[] args) {
		int k = 1;
		int[] a = { 1 };
		k += (k = 4) * (k + 2);
		a[0] += (a[0] = 4) * (a[0] + 2);
		System.out.println("k==" + k + " and a[0]==" + a[0]);
	}
}

k==25 and a[0]==25

k += (k = 4) * (k + 2);
a[0] += (a[0] = 4) * (a[0] + 2);

k = k + (k = 4) * (k + 2);
a[0] = a[0] + (a[0] = 4) * (a[0] + 2);

15.26 Expression

Expression:

	AssignmentExpression

15.27 Constant Expression

ConstantExpression:

	Expression

• Literals of primitive type and literals of type String
• Casts to primitive types and casts to type String
• The unary operators +, -, ~, and ! (but not ++ or --)
• The multiplicative operators *, /, and %
• The additive operators + and -
• The shift operators <<, >>, and >>>
• The relational operators <, <=, >, and >= (but not instanceof)
• The equality operators == and !=
• The bitwise and logical operators &, ^, and |
• The conditional-and operator && and the conditional-or operator ||
• The ternary conditional operator ? :
• Simple names that refer to final variables whose initializers are constant expressions
• Qualified names of the form TypeName . Identifier that refer to final variables whose initializers are constant expressions

Examples of constant expressions:

true
(short)(1*2*3*4*5*6)
Integer.MAX_VALUE / 2
2.0 * Math.PI
"The integer " + Long.MAX_VALUE + " is mighty big."

Contents | Prev | Next | Index

Java Language Specification (HTML generated by Suzette Pelouch on February 24, 1998)
Copyright © 1996 Sun Microsystems, Inc. All rights reserved
Please send any comments or corrections to [email protected]