分配一个变量，实际发生了什么，Java

Question

In the following example what actually happens?

int a = 1;
a += (a = 2);

The output is 3, however I wanted to know what actually happens under the covers. For example i know that parentheses have higher priority to + so happening first (a = 2) the expression should become a = 2 + 2 . At runtime first the expression within parentheses should be executed and then a becomes 2. It seems that the first a on the left to + gets "loaded" before of (a = 2) and this last expression does not seem to override the previous loading. In other words I am quite confused to what exactly happens behind the scenes.

If anybody knows, thanks a lot in advance.

Answer 1

From the JLS section §15.26.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.

So for your example we have:

a = (a) + (a = 2)

With the expression evaluated left to right. Hence the output of 3

Answer 2

See the referenced example 15.7.1-2 from http://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.7.1 , which is almost identical to the example you provided. In particular:

If the operator is a compound-assignment operator (§15.26.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 binary operation.

Because of this precedence, the left hand of the += is evaluated first.

It might be confusing to you because of the parentheses, but note the section on parenthesis evaluation: http://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.7.3 , and in particular:

The Java programming language respects the order of evaluation indicated explicitly by parentheses and implicitly by operator precedence.

In this case, the implicit precedence set by the += operator indicates that the left hand operand will be remembered per the spec. While it's true that assignment operators, including "+=" have lowest precedence, the spec for += indicates that the left-hand operand will be remembered per 15.26.2.

Answer 3

Let's take a look at the bytecode of the following program:

package A;

public class Test
{
    public static void main(String[] args)
    {
        int a = 1;
        a += (a = 2);
    }
}

We just need to run this command:

javap -c Test.class

to get the following bytecode:

public class A.Test {
  public A.Test();
    Code:
       0: aload_0
       1: invokespecial #1           // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: iconst_1
       1: istore_1
       2: iload_1
       3: iconst_2
       4: dup
       5: istore_1
       6: iadd
       7: istore_1
       8: return
}

---

Explanation:

We will just focus on the two lines inside the main method:

int a = 1;
a += (a = 2);

[ int a = 1; begins here]

0: iconst_1

• Pushes int 1 onto the stack.

-------------
|           |
-------------
|           |
-------------
|     1     |
-------------
    STACK

---

1: istore_1

• Pops int value from the stack to variable 1 ( variable 1 represents a )

-------------
|           |             variable 1
-------------           --------------
|           |           |     1      |
-------------           --------------
|           |
-------------
    STACK

[ int a = 1; finishes here]

---

[ a += (a = 2); begins here]

2: iload_1

• Loads an int value from local variable 1 and pushes it onto the stack.

-------------
|           |             variable 1
-------------           --------------
|           |           |            |
-------------           --------------
|     1     |
-------------
    STACK

---

3: iconst_2

• Pushes int 2 onto the stack.

-------------
|           |             variable 1
-------------           --------------
|     2     |           |            |
-------------           --------------
|     1     |
-------------
    STACK

---

4: dup

• duplicate the value on top of the stack.

-------------
|     2     |             variable 1
-------------           --------------
|     2     |           |            |
-------------           --------------
|     1     |
-------------
    STACK

---

5: istore_1

• Pops int value from the stack to variable 1 .

-------------
|           |             variable 1
-------------           --------------
|     2     |           |      2     |
-------------           --------------
|     1     |
-------------
    STACK

---

6: iadd

• Adds the top two values together.

-------------
|           |             variable 1
-------------           --------------
|           |           |      2     |
-------------           --------------
|     3     |
-------------
    STACK

---

7: istore_1

• Pops int value from the stack to variable 1 .

-------------
|           |             variable 1
-------------           --------------
|           |           |      3     |
-------------           --------------
|           |
-------------
    STACK

[ a += (a = 2); finishes here]

---

8: return

• The main method returns.

---

Conclusion:

a = a + (a = 2) is done through several operations. 2: iload_1 is executed as first command of a += (a = 2); which reads the first operand of the equation a = a + (a = 2) and pushes onto the stack.

Next, 3: iconst_2 and 4: dup are executed which basically push int 2 twice onto the stack; one for loading it to a and the other as the second operand. After that, 5: istore_1 is executed which is loading 2 into a ( a = 2 ).

Finally, 6: iadd and 7: istore_1 are executed where 6: iadd adds the first operand and the second operand and pushes the result onto the stack, and 7: istore_1 pops the result and loads it into a .

---

For simplicity, let's have a quick look at this code:

int a = 1;
int b = 3;
a += b;

and here is its bytecode:

public class A.Test {
  public A.Test();
    Code:
       0: aload_0
       1: invokespecial #1            // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: iconst_1
       1: istore_1
       2: iconst_3
       3: istore_2
       4: iload_1
       5: iload_2
       6: iadd
       7: istore_1
       8: return
}

As you can see, it simply does the following:

• Loads int 1 into a .
• Loads int 3 into b .
• Pushes a then b onto the stack.
• Performs the addition on them and pushes the result onto the stack.
• Pops the result from the stack and stores it into a .