ну ни фига не понятно

int a = 3; int b = ++a + (a-- * ++a); 1) - получается первая ++а(увеличится сразу до 4х) итог 4+(а-- + ++а) 2) - вторая а(которая а--) будет равна, так как на её место пойдет первая а, итог 4 + (4-- + ++а) 3) - третья а должна после инициализации уменьшится на 1(т.к. 4--) и увеличится на 1 (т.к. ++а) итог 4+(4+ (4 которую уменьшаем на 1(по тому что она должна быть значением этого "4--"), потом увеличиваем на 1)

как ты получил ++4 + (16 - 1)? там должно быть ++3 + (16)

смотри, сначала операция в скобках, перед умножением ++а = 3 увеличивается на 1 (везде где есть а в этом уравнении), после того как результат в скобках уже посчитана сначала первое а уже ранее увеличенное на 1 еще раз увеличивается на 1. Или же что бы было понятно так (a + 1) + (a * (a + 1) - 1).

не всё так просто

int a = 3;
int b = a * ++a;

чему равно b?

Не логично. Сначала идут скобки: (3-- * ++3) == (4-- * 4) == 16 (после того, как скобки посчитали, происходит "а--" и, соответственно, "а" становится == 3. далее левая часть выражения: ++3 + 16 == 4 + 16 == 20; Выражение в скобках уже посчитано и из него не отнимается "-1", так как "-1" отнимается от "а" после завершения выражения в скобках.

Сначала, перед тем как начать выполнять вычисление значения выражения, джава гарантирует, что известно значение каждого операнда этого выражения. Поэтому сначала не обращая внимания на скобки выполняются последовательно вычисления каждого операнда:

int a = 3;
++a; // 4
a--; // 4, но здесь не a = 4, а именно операнд a-- равен 4, а значение переменной a становится равно трём
++a; // 4

И потом уже после того, как все операнды были вычислены, джава-машина выполняет вычисление выражения:

4 + (4 * 4) = 20

Кстати, скобки тут не нужны, т.к. умножение и без них приоритетнее, чем сложение, а на порядок вычисления операндов скобки не влияют.

У скобок приоритет выше, поэтому ++4 + (4-- * 4) = ++4 + (4 * 4) /* держим в уме -- */ = ++3 + 16 = 20. Если б скобок не было при такой же расстановке инкрементов/декрементов, получилось бы 5 + 5 * 5 = 30, а только после этого значение a уменьшилось бы на 1

Нельзя вообще писать ++4, это не валидная запись. Инкременты можно использовать только с целочисленными переменными. Это первое. Второе - это собственно то, что уже написано в моём предыдущем комментарии, а именно- значение всех операндов вычисляется ДО начала вычисления значения всего выражения. Это никак не связано с наличием или отсутствием скобок. Это прописано в спецификации языка, читай JLS: 15.7.2. Evaluate Operands before Operation The Java programming language guarantees that every operand of an operator (except the conditional operators &&, ||, and ? :) appears to be fully evaluated before any part of the operation itself is performed. Скобки расставляют только приоритеты между арифметическими операциями. А вычисление значения выражения начнётся только после того, как выполнится вычисление значение для каждого из операндов в отдельности. Другими словами, запись вида a++ – это не число, а некоторая функция, и прежде чем начать вычислять значение выражения, смотреть вообще где там скобки, программе требуется знать, какое значение эта функция (инкремент) возвращает. А эта функция по ходу своего вычисления меняет и текущее значение своего параметра (переменной a).

И в чём тогда отличие префиксной записи от постфиксной, если они одинаково работают?

Где я написал, что они работают одинаково? Я написал, что обе функции вычисляются до начала вычисления арифметических выражений. А отличие в том, что постфикс возвращает текущее значение аргумента и при этом увеличивает сам аргумент, а префикс увеличивает аргумент и затем возвращает его новое значение.

Вот оно!то чего не догнал.Спасибо.

с этим примером понятно, но вопрос почему в другом примере int a = 3; int b = --a + (a-- * ++a); b получается 6 в компиляторе, как это возможно если считать в уме получается 18 --3 + (3-- * ++3) --4 + (4-- * 4) --3 + 16 2+16

нужно смотреть приоритет операторов, но по сути 6 ты можешь получить только 2*2+2 по другому никак

попробовал поэкспериментировать и узнал для себя неприятный сюрприз оказывается

int a = 3;
a * ++a  // эквивалентно 3 * 4 итог: 12
a-- * ++a  // эквивалентно 3 * 3 итог: 9

т.е. постфиксный декремент и префиксный инкремент компенсируются, а вот такая запись

--a + (a-- * ++a) // эквивалентно 2 + (2 * 2) итог: 6

т.е. сначала срабатывают все декременты потом инкремент и толь после матеметические операции у меня такое ощущение что компилятор шалит...

Всё правильно. Согласно 15.7.2 спецификации джавы у тебя, прежде чем приступить к вычислению значения выражения, вычисляются все значения операндов. Это происходит справа налево. Именно поэтому твоё выражение эквивалентно 2 + 2 * 2, и a после его вычисления также равно двум, т.к. последний унарный оператор был префиксом, т.е. не изменял значение a после вычисления.