Порядок операций с логикой в ​​Java Confused

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 

В конце концов, когда (((a++) == 2) || ложный) [a = 1] Делается тогда как || оператор имеет меньший приоритет, чем ++, поэтому здесь a станет 3 .. тогда он напечатает a=3 Хотя это оператор короткого замыкания, он все равно должен выполнять оператор ++ 1st.

Из Спецификация языка Java,

The conditional-or operator || operator is like | (§15.22.2), but evaluates its right-hand operand only if the value of its left-hand operand is false.

Итак, это проще, чем вы думаете. res = a++ == 2 || --a == 2 && --a == 2; оценивается так:

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

a++ == 2? Постинкремент означает, что а читается как 2. Затем это выражение оценивается. 2 == 2, это правда. Короткое замыкание означает, что остальная часть выражения оценивается как никогда.

Итак, по сути, весь приведенный выше код — это 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);

Как мы видим, && имеет приоритет, поэтому выражения слева и справа от него группируются вместе, затем вычисляется ||. Выражение слева от него — x, а выражение справа — (y && z) (я думаю, мы оба думали, что если && имеет приоритет, оно будет похоже на (a || b) && c, поэтому оно будет оцениваться первым, но это не так). Если мы хотим убедиться, что это действительно так, мы можем изменить приведенный выше код следующим образом:

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

Это эквивалентно false || (false && false), но без какого-либо вмешательства компилятора в константы времени компиляции. Результатом этого является:

One called with 8
Two called with 16
false 16

Сначала оценивается ||, затем левая часть &&. Это возвращает false, а false && ? всегда будет false, поэтому третье выражение не оценивается. Но правила приоритета не были нарушены. Я надеюсь, что это прояснило любую путаницу. Если нет, я буду рад продолжить обсуждение в чате и обновить свой ответ. Поскольку из исходного кода мы знаем, что если первое выражение истинно, || возвращает истину и замыкается, мы можем сказать, что a || b && c не сгруппировано в (a || b) && c.