Compound Assignment Operators

All compound assignment operators require both operands to be of primitive type, except for +=, which allows the right-hand operand to be of any type if the left-hand operand is of type String or of one of the type specified in Table - Prompt Concatenation Conversion Result if the left-hand operand is of type Prompt.

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

The implied cast to type T may be either an identity conversion or a narrowing primitive conversion.

For example, the following code is correct. 


short x = 3;
x += 4.6;

and results in x having the value 7 because it is equivalent to: 


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

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 four steps are required:

  1. 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.

  2. 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.

  3. 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), then the assignment expression completes abruptly for the same reason and no assignment occurs.

  4. 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.

If the left-hand operand expression is an array access expression, then many steps are required:

  1. 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.

  2. 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.

  3. Otherwise, if the value of the array reference subexpression is null, then no assignment occurs and a NullPointerException is thrown.

  4. 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 ArrayIndexOutOfBoundsException is thrown.

  5. 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.)

  6. 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 parse 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), 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 selected 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 or a Prompt. Because class String is a final class, S must also be String if this is a string compound assignment operator. If it is a prompt compound assignment operator then the S can be assignment compatible with the Prompt reference type. 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 or prompt 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.

  7. Otherwise, the String, Prompt, or Document result of the binary operation is stored into the array component.