Simple Assignment Operator =

15.26.1 Simple Assignment Operator =

A compile-time error occurs if the type of the right-hand operand cannot be converted to the type of the variable by assignment conversion (§5.2).

At run-time, the expression is evaluated in one of three ways. If the left-hand operand expression is a field access expression (§15.11) e.f ,

possibly enclosed in one or more pairs of parentheses, then: • First, the expression e is evaluated. If evaluation of e completes abruptly, the

assignment expression completes abruptly for the same reason. • Next, the right hand operand is evaluated. If evaluation of the right hand

expression completes abruptly, the assignment expression completes abruptly for the same reason.

• Then, if the field denoted by e.f is not static and the result of the evaluation of e above is null , then a NullPointerException is thrown.

• Otherwise, the variable denoted by e.f is assigned the value of the right hand operand as computed above.

If the left-hand operand is an array access expression (§15.13), possibly enclosed in one or more pairs of parentheses, then:

• 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

EXPRESSIONS Simple Assignment Operator = 15.26.1

than or equal to the length of the array, then no assignment occurs and an ArrayIndexOutOfBoundsException 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. Then there are two possibilities:

◆ If TC is a primitive type, then SC is necessarily the same as TC . The value of the right-hand operand is converted to the type of the selected

array component, is subjected to value set conversion (§5.1.13) to the appropriate standard value set (not an extended-exponent value set), and the result of the conversion is stored into the array component.

◆ If TC is a reference type, then SC may not be the same as TC , 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.

A Java 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 a Java 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.5, §15.16), except that if the check fails, an ArrayStoreException is thrown rather than a ClassCastException .

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.

Otherwise, 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.

15.26.1 Simple Assignment Operator = EXPRESSIONS

• 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, is subjected to value set conversion (§5.1.13) to the appropriate standard value set (not an extended-exponent value set), and the result of the conversion is stored into the variable.

Example 15.26.1-1. Simple Assignment To An 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!");