Java语言中逻辑运算顺序混乱

Question

我有一个小测验中的操作顺序问题，解释并没有什么帮助。代码如下：

package com.udayan.oca;

public class Test {
     public static void main(String [] args) {
         int a = 2;
         boolean res = false;
         res = a++ == 2 || --a == 2 && --a == 2;
         System.out.println(a);
     }
}

它说它打印了3个，因为我测试过，但我不明白怎么做。以下是他们的解释：

a++ == 2 || --a == 2 && --a == 2;

[给定表达式].（a）==2||--a==2

[后缀的优先级高于其他运算符]。

(a++) == 2 || (--a) == 2 && (--a) == 2;

[后缀后，前缀优先]。

((a++) == 2) || ((--a) == 2) && ((--a) == 2);

[==的优先级高于

((a++) == 2) || (((--a) == 2) && ((--a) == 2));

[

让我们开始解决它：（（a）==2) || (((--a）==2）

[a=2，res=false]。

(2 == 2) || (((--a) == 2) && ((--a) == 2));

[a=3，res=false]<代码>真| |（（（-a）==2）

[a=3，res=false]。

||是短路运算符，因此不需要计算右侧的表达式。

res为真，a为3。

是的，顺便说一句，我理解短路，所以不需要解释。

然而，我的想法是：

res = a++ == 2 || --a == 2 && --a == 2 ->
(((a++) == 2) || (((--a) == 2) && ((--a) == 2))) [a = 2]

(((a++) == 2) || ((**1** == 2) && ((--a) == 2))) [a = 1]

(((a++) == 2) || (**false** && (**0** == 2))) [a = 1] //short-circuits

(((a++) == 2) || **false**) [a = 1] //short circuits

(**false**) [a = 1]

???? 另一点是答案键说先做一个，然后再做下一个。是啊，这很有道理。但是我想




Answer 1

最后当（（a）=2）| | false）[a=1]完成时，作为| |运算符的优先级比这里的低，a将变为3。。然后它将打印a=3，尽管它是一个短路操作员，但它必须先执行操作员。

Answer 2

res = a++ == 2 || --a == 2 && --a == 2 (res is true)

1. a++ (post-increment, no) -> a = a + 1 -> it's still 2 -> when true -> it becomes 3
2. --a (pre-increment, right to left) -> a - 1 = a -> 1
3. --a (pre-increment, right to left) -> a - 1 = a -> 0 (its because of logical and, it never execute this part) 
4. == (equality, left to right) -> 2 == 2 || 1 == 2 && 0 == 2 -> true || false && false
5. && (logical and, left to right) -> false -> no more steps 
6. || (logical or, left to right) -> true -> go to 1.

// so take 3
// moral of the story is always use paranthesis
// op is correct for short-circuit 

Answer 3

根据Java语言规范，

条件or运算符| |运算符类似于|（§15.22.2），但仅当其左侧操作数的值为false时才计算其右侧操作数

所以，这比你想象的要简单。res=a==2||--a==2

res = ((a++ == 2) || ((--a == 2) && (--a == 2)));

a==2？后增量表示a读作2。然后计算该表达式。2==2，这是true。短路意味着表达式的其余部分永远不会被计算。

所以，基本上上面的所有代码都是res=a==2；

我做了一个简单的程序来测试这个：

public class TestSOCode {
    public static void main(String [] args) {
        test1();
    }

    private static void test1(){
        int a = 2;
        boolean res = false;
        //res = a++ == 2 || --a == 2 && --a == 2;
        res = expression(a++, "One") || expression(--a, "Two") && expression(--a, "Three");
        System.out.println(res +" "+ a);
    }

    private static boolean expression(int i, String s){
        System.out.println(s+ " called with "+ i);
        return i == 2;
    }
}

这就是结果

One called with 2
true 3

更新：经过一些讨论和研究，我认为在逻辑运算符方面，对优先级和执行顺序之间的区别存在误解。

res = a++ == 2 || --a == 2 && --a == 2;

上述语句的优先级是在对其进行计算之前计算出来的。我将不讨论其他优先规则，因为它会使这个答案复杂化，所以我将简化它：

res = x || y && z;

res = x || (y && z);

如我们所见，

 res = expression(a = 8, "One") || expression(a = 16, "Two") && expression(a = 32, "Three");

这相当于false | |（false

One called with 8
Two called with 16
false 16

首先计算||，然后计算的左侧