Почему префикс оценивается перед постфиксом в выражении, содержащем оба?

Операнды операторов всегда оцениваются слева направо, независимо от порядка операций, определяемого приоритетом.

Вот что происходит:

1. Оцените --x. Устанавливает x в 4, дает 4.
2. Оцените (--x) * 5. x на данный момент равно 4, поэтому это оценивает 4 * 5 и дает 20.
3. Оцените x--. Дает 4, устанавливает x в 3.
4. Оцените ((--x) * 5) + x--;. Добавляет 20 к 4, чтобы получить 24.
5. Распечатать "3 vs 24".

JLS, раздел 15.7 , состояния:

Язык программирования Java гарантирует, что операнды операторов вычисляются в определенном порядке вычисления, а именно слева направо.

Приоритет оператора не имеет ничего общего с порядком, в котором оцениваются операнды. Операнды всегда оцениваются слева направо.

Приоритет оператора определяет, как оцениваются выражения. Например, выражение 4 * 5 + 6 может означать (4 * 5) + 6 или 4 * (5 + 6). Поскольку * имеет более высокий приоритет оператора, правильным будет первый.

И префикс, и постфикс декремента и инкремента имеют высокий приоритет оператора, поэтому --x * 5 означает (--x) * 5, а не --(x * 5). Очевидно, что последнее выражение вызовет ошибку компилятора, поскольку x * 5 не является переменной. По этой причине декремент и инкремент префикса и постфикса имеют высокий приоритет операций: нет смысла оценивать --x * 5 как --(x * 5).

Таким образом, в вашем случае выражение эквивалентно ((--x) * 5) + (x--). Затем это выражение можно вычислить, где операнды оцениваются строго слева направо.

Операнды оцениваются слева направо, что вы считаете справа налево. Итак, --x получает значение 4, затем --x*5, что равно 4*5 как 20. А затем --x*5 + x-- делает его равным 24. И, наконец, x-- оценивается как 3.

Из документов Java:

Язык программирования Java гарантирует, что операнды операторов вычисляются в определенном порядке, а именно слева направо.

Вот хорошая подробная статья о приоритете Java.

Итак, компилятор Java находит это выражение:

int x = 5;
int y = --x * 5 + x--;

и должен определить порядок операций для генерации байт-кодов. В строке четыре оператора: --, *, + и --, и ни одной скобки, поэтому хороший компилятор проверяет свою таблицу приоритетов и ставит скобку, которую вы, ленивый программист, пропустили:

((--OP1) * OP2) + (OP3--) 

Обратите внимание, что на этом этапе операнды являются непрозрачными объектами: не имеет значения, являются ли они переменными (которые подразумевают чтение из памяти), константами, вызовами методов, неявными распаковками или чем-то еще — процессу заключения в скобки это знать не нужно.

Наконец, при выдаче байт-кодов компилятор должен соблюдать еще одно правило: операнды должны оцениваться слева направо, чтобы операции чтения и записи в память (например, декремент/инкремент переменных и вызовы методов) имели гарантированный порядок. Так что должно быть так, что в последовательности инструкций:

OP1
...
OP2
...
OP3

Давайте перейдем к объектно-ориентированному IntegerVariable, чтобы увидеть более наглядный пример:

public class IntegerVariable {

    private int val;

    public IntegerVariable(int val) {
        this.val = val;
    }

    public int getAndDecrement() {
        return val--;
    }

    public int decrementAndGet() {
        return --val;
    }

    public int get() {
        return val;
    }

    public static IntegerVariable Int(int val) {
        return new IntegerVariable(val);
    }

    public static void main(String... args) {
        IntegerVariable x = Int(5);
        int y = x.decrementAndGet() * Int(5).get() + x.getAndDecrement();
    }
}

Если вы установите точки останова на get(), decrementAndGet() и getAndDecrement(), вы ясно увидите разницу между

• порядок оценки, который можно отлаживать с помощью виртуальных вызовов. Порядок оценки слева направо, и вам гарантируется, что операнд полностью вычисляется до выполнения операции.
• приоритет оператора, который в основном просто ставит круглую скобку, которую вы пропустили: y = ((--x) * 5) + (x--)

x-- происходит после выполнения инструкции. так что это было как 4*5+4; и после выполнения этого оператора x снова уменьшился до 3.

Вот почему 3 и 24