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

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

Почему тогда в этом выражении получается 9 ? int a = 3; int b = (a-- * ++a); System.out.println(b);

Потому что 3 * 3 = 9, разве не очевидно? Если ты из тройки вычитаешь единицу, а потом добавляешь, сколько будет?

Подробно: слева направо, поехали, вместо первой а подставляется число три. Потом постдекримент, а становится равно двум. Следующее подставление, преинкримент, а сначала увеличивается на 1, получается 3, поэтому подставляется три. Потом как Денис написал, умножается. Скобки, кстати, не нужны.

4 + 4 * 4. 1. Сначала вычисляется и подставляется ++a. ++a делает a равным 4 и возвращает (подставляет в выражение) изменённое значение, равное 4. 2. Потом вычисляется и подставляется постдекремент a--. Поскольку a в текущий момент уже равно 4 после первого действия, постдекремент возвращает текущее значение 4 и затем делает а, равным 3. Принцип постинкремента/декремента заключается именно в том, что он сначала возвращает текущее значение, и только потом изменяет значение аргумента а. Поэтому он и называется «пост». 3. Текущее значение a равно 3. Поэтому при выполнении преинкремента ++а сначала значение a становится равным 4, и затем увеличенное значение возвращается (подставляется в выражение).

Я кажется разобрался. Скобочки - инкремент - мультипликативное действие (умножение) - пост декремент - инкремент - аддитивное действие (сложение). Тут очень важен приоритет пошаговый, а не какое то абстрактное представление, компилятор ничего не представляет, он именно пошагово выполняет код.

Последнее предложение пытался понять, но не смог. Найди ниже спецификацию JLS, я приводил цитату. Суть в том, что прежде чем вычислять всю арифметику, сначала вместо каждой функции подставляется результат. Это делается просто по порядку слева направо. А потом, когда все значения функций станут вычислены, начинается арифметика согласно правилам приоритета.

int a = 3; int b = a-- * ++a; тут должно быть решение такое a = 4 до умножения и а = 3 после, но компилятор женщина, он рисует 9 в консоле. По моей логике 4 * 4 = 16, по вашей 3 * 4 = 12. А компилятор рисует 9. Тут нету логики.

инкремент выполняется до умножения, а пост декремент после, так что там 4 * 4, а не 3 * 3.

int a = 3; int b = a-- * ++a; System.out.println(b); //выводит 9, должен выводить 16. Если инкремент - умножение - декремент. Это баги какие то. ++a это 4, но никак не 3.

Чувак, не тупи, тут и так разжевали уже как для моей бабушки. Не веришь людям - почитай спецификацию языка. https://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.7.2 когда ++ стоит справа от переменной это постинкремент, т.е. значение берётся, потом меняется 3++ участвующее в выражении это один хрен три при подсчете. если же операция стоит слева то выполняется сначала она потом берётся значение. --4 = 3 Именно по этому в твоём примере 3 * 3 = 9, и никаких багов тут нет. Я понимаю что все непонятное пугает, но называть багами любую вещь которая тебе непонятна это как минимум глупо, язык писали люди неизмеримо умнее и талантливей чем ты когда либо станешь, а ты тут находишь баги в многолетнем труде :) За 20 лет никто не нашёл, а ты вот справился за вечер. Ну надо же хоть иногда в голову не только есть но и думать.

где ты тут видишь 3++ ? int a = 3; int b = a-- * ++a;

Ну хорошо, а какая разница?) все равно изначально берётся три, потом из него вычитается единица потом добавляется единица и снова берётся три. Как ни перекручивай, все равно для подсчёта перемножаются именно тройки. Вот так вот работают операции пре и пост инкремента\декремента

Я понял, в чем ты заблуждаешься. Ты взял изначально полное выражение ++a + (a-- * ++a), дальше тебе сказали, что в скобках будет 4*4, значит ты берёшь только скобки, а там вместо 16 получается 9. Это действительно так, потому что в скобках получится 16 только потому, что перед скобками есть ++а, которое первое слагаемое! Почитай ответы выше ещё раз. Все функции вычисляются слева направо по порядку, плевать на скобки и приоритеты математических операторов. Первым подставляется аргумент и вычисляется ++а. После него а становится уже равно 4. И только после этого вычисляется значение аргументов в скобках. Смотри, любой постинкремент или постдекремент ты можешь заменить на два действия:

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

Здесь b — это значение, которое подставится вместо а++. А преинкремент представляет собой другую последовательность:

// int c = ++a;
a = a + 1;
int c = a;

И тебе нужно подставить эти последовательности во всё выражение. Заменим по порядку все инкременты и декременты на переменные:

int a = 3;

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

// int c = a--;
int c = a; // 4
a = a - 1; // 3

// int d = ++a;
a = a + 1; // 4
int d = a; // 4

// ++a + (a-- * ++a):
// только в этот момент начинают играть роль скобки и прочие приоритеты операторов!
int result = b + c * d; // 4 + 4 * 4 = 20

Дэнчик, до меня дошло. Оказывается постдекремент вычисляется раньше умножения, вот пример: int a = 3; int b = a-- + ++a + (a-- * ++a); System.out.println(b); в консоле 15. Почему? Да потому, что пост декремент (a--) за скобками вычислил значение переменной и вернул (3 - 1 = 2) двойку. А далее инкремент (2 + 1 = 3), потом пост декремент (3 - 1 = 2) и опять инкремент (2 + 1 = 3). В итоге мы получаем a = 3. Из этого получаем формулу 3 + 3 + (3 * 3) = 15. Скобки не имеют высшего приоритета, высший приоритет у функции, не важно, она пре или пост. Спасибо за помощь друзья :)

как ты получил ++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 после вычисления.