为什么这里忽略 Java 运算符优先级？

Question

以下代码打印出“3”，而不是您所期望的“4”。

public class Foo2 {
    public static void main(String[] args) {
        int a=1, b=2;             
        a = b + a++;
        System.out.println(a);
    } 
}

我明白了。后缀增量发生在加载“a”的值之后。 （见下文）。

我不太明白的是为什么。 postfix ++ 的运算符优先级高于 + 那么它不应该先执行吗？

% javap -c Foo2

Compiled from "Foo2.java"
public class Foo2 extends java.lang.Object{
public Foo2();
  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_2
   3:   istore_2
   4:   iload_2
   5:   iload_1
   6:   iinc    1, 1
   9:   iadd
   10:  istore_1
   11:  getstatic       #2; //Field java/lang/System.out:Ljava/io/PrintStream;
   14:  iload_1
   15:  invokevirtual   #3; //Method java/io/PrintStream.println:(I)V
   18:  return

Answer 1

Postfix ++ 递增变量的值，并返回递增之前的值。因此，示例中 operator++ 的返回值为 1，当然 1 + 2 会给出 3 >，然后将其分配给a。在赋值时，++ 已将 a 的值增加到 2（因为优先级），因此 =< /code> 覆盖该增加的值。

Answer 2

这里不会忽略运算符优先级。

关于 a++ 唯一有点令人困惑的是，后缀 ++ 运算符有两个不同的效果：

1. 它将所应用的变量增加 1，
2. 它的返回值等于到变量之前的值增加

所以如果a在这一行之前有1并且b有值2：

a = b + a++;

那么以下步骤发生：

• 评估b
  • 表达式b的值为2，所以记住值2
• 计算 a++
  • 表达式 a++ 的值为 1，因此请记住值 1
  • 将变量 a 中的值增加 1，因此它现在的值为 2
• 添加结果两个表达式（分别为 2 和 1）的
• 2 + 1 = 3
• 将 3 赋给变量 a

如您所见，代码有效地将两个值赋给 a：

• 2 在 a++ 求值期间被分配给 a
• 3 作为分配结果被分配给 a

因为第二次分配发生在第一次分配之后第一个，您只能看到第二个的效果，并且您将始终观察到该行之后的 a 值为 3。

编辑：我将尝试提供反编译代码的解释。除非您知道 JVM 内部如何工作（即您知道 JVM 是基于堆栈的 VM 以及这意味着什么），否则可能有点难以理解：

   // Push the constant 1 on the stack
   0:   iconst_1
   // Pop the topmost value from the stack (1) and store it in the local variable #1 (a.k.a "a")
   1:   istore_1
   // Push the constant 2 on the stack
   2:   iconst_2
   // Pop the topmost value from the stack (2) and store it in the local variable #2 (a.k.a "b")
   3:   istore_2
   // Load the local variable #2 ("b") and push its value (2) on the stack
   4:   iload_2
   // Load the local variable #1 ("a") and push its value (1) on the stack
   5:   iload_1
   // Increment the local variable #1 by 1 (this action does not use the stack!)
   6:   iinc    1, 1
   // Pop the 2 topmost values from the stack (2 and 1), add them and push the result (3) back on the stack
   9:   iadd
   // Pop the topmost value from the stack (3) and store it in local variable #1 ("a")
   10:  istore_1

第 0-3 行简单地实现

int a=1, b=2;

第 4-10 行实现

a = b + a++;

I省略了其他行，因为那里不再发生任何有趣的事情。

作为一个有趣的旁注：很明显，这段代码根本没有优化。原因是优化是 Java 世界中运行时环境（即 JVM）的任务，而不是编译器（例如 javac）的任务。

Answer 3

后自增/自减运算符 (a++) 返回自增之前的值。预增/预减 (++a) 返回增量后的值。

Answer 4

我对这个运算符优先级定义也有同样的问题（如此处定义的）我认为上述答复都没有准确解释和澄清这个定义中的悖论。
这就是我认为后缀运算符相对于其他运算符（在本例中为二元加运算符）的更高优先级的含义。

考虑以下代码片段：

    int x = 1, y =4 , z;
    z = x+++y;  // evaluates as: x++ + y
    System.out.println("z : " + z); // z: 5
    System.out.println("y : " + y); // y: 4
    System.out.println("x : " + x); // x: 2

    x = 1; y =4 ; 
    z = x + ++y;
    System.out.println("z : " + z); // z: 6
    System.out.println("y : " + y); // y: 5
    System.out.println("x : " + x); // x: 1

如您所见，具有两个可能计算值的单个表达式 z = x+++y; 将被计算为 z = x++ + y;代码>由java编译器。这意味着，对于组合在一起的三个加号，编译器假定前两个加号为后缀运算符，第三个加号为二元加运算符。 这实际上是后缀运算符比其他运算符具有更高优先级的结果。

第二个代码片段通过将表达式编写为 z = x + ++y; 来显示输出的不同之处。 code> 明确指定哪个加号是二元运算符。

Answer 5

这不是优先级问题，而是运算符的定义问题。 根据定义后缀运算符在封闭表达式中使用变量后执行。

Answer 6

后缀 ++ 运算符的意思是：

在任何方程中使用变量的原始值，然后递增变量。

Answer 7

我从未见过

 a = b + a++; 

被使用过，它让我觉得编码很糟糕。像这样使用它我认为也意味着你可以写：

int a++ = 1;

这是行不通的。

通常你会看到

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

a = 1;
a++;
a = b + a; // 4