Можете ли вы объяснить мне результат этого Java-кода?
int a=5,i;
i=++a + ++a + a++;
i=a++ + ++a + ++a;
a=++a + ++a + a++;
System.out.println(a);
System.out.println(i);
В обоих случаях вывод равен 20.
Это помогает?
a = 5;
i=++a + ++a + a++; =>
i=6 + 7 + 7; (a=8)
a = 5;
i=a++ + ++a + ++a; =>
i=5 + 7 + 8; (a=8)
Суть в том, что ++a увеличивает значение и немедленно возвращает его.
a++ также увеличивает значение (в фоновом режиме), но возвращает неизменное значение переменной - то, что выглядит, как будто выполняется позже.
++a увеличивает, а затем использует переменную. a++ использует, а затем увеличивает эту переменную.
Если у вас
a = 1;
и вы делаете
System.out.println(a++); //You will see 1
//Now a is 2
System.out.println(++a); //You will see 3
@codaddict объясняет ваш конкретный фрагмент.
В обоих случаях он сначала вычисляет значение, но в post-increment он имеет старое значение и после вычисления возвращает его
++ а
а ++
i = ++a + ++a + a++;
является
i = 6 + 7 + 7
Рабочая: приращение a до 6 (текущее значение 6) + приращение a до 7 (текущее значение 7). Сумма 13 теперь добавляет ее к текущему значению a (= 7), а затем увеличивает значение a до 8. Сумма равна 20, а значение a после завершения присваивания равно 8.
i = a++ + ++a + ++a;
является
i = 5 + 7 + 8
Работа. При стартовом значении a это 5. Используйте его в добавлении, а затем увеличьте его до 6 (текущее значение 6). Приращение a от текущего значения 6 до 7 для получения другого операнда+. Сумма равна 12, а текущее значение a равно 7. Следующее приращение a от 7 до 8 (текущее value = 8) и добавление его к предыдущей сумме 12 для получения 20.
++a увеличивает a до его вычисления.
a++ оценивает a, а затем увеличивает его.
Относительно вашего выражения:
i = ((++a) + (++a) + (a++)) == ((6) + (7) + (7)); // a is 8 at the end
i = ((a++) + (++a) + (++a)) == ((5) + (7) + (8)); // a is 8 at the end
Предыдущие, которые я использовал выше, неявно используются Java. Если вы посмотрите на термины таким образом, вы можете легко увидеть, что они оба совпадают, поскольку они являются коммутативными.
В приведенном выше примере
int a = 5,i;
i=++a + ++a + a++; //Ans: i = 6 + 7 + 7 = 20 then a = 8
i=a++ + ++a + ++a; //Ans: i = 8 + 10 + 11 = 29 then a = 11
a=++a + ++a + a++; //Ans: a = 12 + 13 + 13 = 38
System.out.println(a); //Ans: a = 38
System.out.println(i); //Ans: i = 29
++ a является приращением приращения:
a ++ - оператор приращения постфикса:
Как только вы запомните правила, EZ, чтобы вычислить все!
когда a равно 5, тогда a++ дает 5 выражению и приращает a после этого, а ++a увеличивает a перед передачей числа в выражение (которое дает a 6 на выражение в этом случае).
Итак, вы вычисляете
i = 6 + 7 + 7
i = 5 + 7 + 8
Я полагаю, однако, если вы объедините все свои заявления и запустите их в Java 8.1, вы получите другой ответ, по крайней мере, то, что говорит мой опыт.
Код будет работать следующим образом:
int a=5,i;
i=++a + ++a + a++; /*a = 5;
i=++a + ++a + a++; =>
i=6 + 7 + 7; (a=8); i=20;*/
i=a++ + ++a + ++a; /*a = 5;
i=a++ + ++a + ++a; =>
i=8 + 10 + 11; (a=11); i=29;*/
a=++a + ++a + a++; /*a=5;
a=++a + ++a + a++; =>
a=12 + 13 + 13; a=38;*/
System.out.println(a); //output: 38
System.out.println(i); //output: 29
Предполагая, что вы имели в виду
int a=5; int i;
i=++a + ++a + a++;
System.out.println(i);
a=5;
i=a++ + ++a + ++a;
System.out.println(i);
a=5;
a=++a + ++a + a++;
System.out.println(a);
Это оценивает:
i = (6, a is now 6) + (7, a is now 7) + (7, a is now 8)
так что я 6 + 7 + 7 = 20 и поэтому 20 печатается.
i = (5, a is now 6) + (7, a is now 7) + (8, a is now 8)
так что я 5 + 7 + 8 = 20 и поэтому 20 печатается снова.
a = (6, a is now 6) + (7, a is now 7) + (7, a is now 8)
и после того, как вся правая часть будет оценена (включая установку a в 8), ТО а устанавливается в 6 + 7 + 7 = 20, и, таким образом, 20 печатается в последний раз.
a=5; i=++a + ++a + a++;
является
i = 7 + 6 + 7
Работа: pre/post increment имеет "справа налево" Ассоциативность, а pre имеет приоритет над пост, поэтому прежде всего pre increment будет решаться как (++a + ++a) => 7 + 6. то a=7 предоставляется для post increment = > 7 + 6 + 7 =20 и a =8.
a=5; i=a++ + ++a + ++a;
является
i=7 + 7 + 6
Работа: pre/post increment имеет "справа налево" Ассоциативность, а pre имеет приоритет над пост, поэтому прежде всего pre increment будет решаться как (++a + ++a) => 7 + 6. then a=7 предоставляется для post increment = > 7 + 7 + 6 =20 и a =8.
pre-increment и post increment эквивалентны, если не в выражении
int j =0;
int r=0
for(int v = 0; v<10; ++v) {
++r;
j++;
System.out.println(j+" "+r);
}
1 1
2 2
3 3
4 4
5 5
6 6
7 7
8 8
9 9
10 10
Я считаю, что вы выполняете все эти утверждения по-разному
выполнение вместе приведет к результату = > 38, 29
int a=5,i;
i=++a + ++a + a++;
//this means i= 6+7+7=20 and when this result is stored in i,
//then last *a* will be incremented <br>
i=a++ + ++a + ++a;
//this means i= 5+7+8=20 (this could be complicated,
//but its working like this),<br>
a=++a + ++a + a++;
//as a is 6+7+7=20 (this is incremented like this)
Предварительное увеличение означает, что переменная увеличивается до того, как вычисляется в выражении. Постинкремент означает, что переменная увеличивается после ПОСЛЕ того, как она была оценена для использования в выражении.
Поэтому посмотрите внимательно, и вы увидите, что все три задания арифметически эквивалентны.
Просто отсылайте эти принципы и этот образ, и вы будете за считанные минуты.
Принцип: -
1.) Когда унарные операторы ++ и - используются в префиксной нотации, значение переменной увеличивается/уменьшается непосредственно перед тем, как переменная используется в выражении.
2.) Когда унарные операторы ++ и - используются в постфиксной нотации, значение переменной увеличивается/уменьшается сразу после того, как переменная используется в выражении.
Пример: - Оценка выражения в изображении начинается слева направо. Предположим, что a должно быть 10.
Your Question:- int a = 5, i; i = ++a + ++a + a++; i = a++ + ++a + ++a; a = ++a + ++a + a++; System.out.println(a); System.out.println(i); Answer:- i = 6 + 7 + 7; [a = 8] i = 8 + 10 + 11; a = 12 + 13 + 13; [a = 14] O/P :- 38 29
class O
{
public static void main(String args[])
{
int i=0;
System.out.println(++i);
System.out.println(i);
System.out.println(i);
System.out.println(i++);
}
}