En general, se cree que el preposición ++ primero agrega el valor de la variable a 1, y luego usa el valor después de agregar 1 para participar en la operación; mientras que el post-posición ++ primero usa el valor para participar en la operación, y luego agrega el valor a 1.
Echemos un vistazo al primer ejemplo:
prueba de paquete; public class plus_test01 {public static void main (string [] args) {int i = 100; i = i ++; System.out.println (i); }}¿Adivina cuál es el resultado?
Veamos el segundo:
prueba de paquete; public class plus_test02 {public static void main (string [] args) {int k = 100; while (true) {if (k ++> 100) {// system.out.println (k); romper; } System.out.println (k); }}}¿Adivina cuál es el resultado?
De hecho, ya sea pre-++ o post-++, el valor de la variable primero aumenta en 1 antes de continuar calculando. La diferencia real entre los dos es: el pre-++ agrega el valor de la variable por 1 y usa el valor agregado para realizar cálculos, mientras que el post-++ primero asigna la variable a una variable temporal, luego agrega 1 al valor de la variable, y luego usa esa variable temporal para realizar cálculos.
Para el siguiente fragmento de código (prefijo ++):
int i = 1;
int j = ++ i*5;
De hecho, la segunda oración es equivalente a:
i+= 1; // Agregar i a 1
j = i*5; // Calcule el valor después de agregar 1 con él, el resultado es: 10
Y para el siguiente fragmento de código (post-++):
int i = 1;
int j = i ++*5;
La segunda oración es equivalente a:
int temp = i; // asignar i a una variable temporal
i+= 1; // Agregar i a 1
j = temp*5; // Calcule la variable temporal con ella, el resultado es: 5
Para el primer ejemplo, es equivalente a:
int temp = i;
i+= 1;
i = temp; //
Entonces el resultado debe estar sin cambios, es decir, 100.
El código de ensamblaje para el primer ejemplo es:
Public static void main (java.lang.string []); Descriptor: ([lJava/lang/string;) V banderas: acc_public, ac a ac_static: stack = 2, locals = 2, args_size = 1 0: bipush 100 2: istore_1 3: iload_1 4: iinc 1, 1 // el segundo uno en la var local 1 7: istore_1 // salvo a la var 8: getstatic 16/ java/lang/system.out: ljava/io/printstream; 11: ILOAD_1 // El parámetro cargado es el segundo en la pila, es decir, sigue siendo 100 12: InvokeVirtual #22 // Método Java/io/printstream.println: (i) v 15: Return
Para el segundo ejemplo, en realidad no es difícil, pero el resultado es 101. Presta atención al proceso y no puedes cometer tales errores en el futuro. (El proceso es: Primero compare temp = i, temp> 100, obviamente no se mantiene verdadero. Skip i+= 1 a la oración SYSO, por supuesto, imprima 101, bucle nuevamente nuevamente, y también hay temp = i, temp> 100, esta vez es verdadero, y luego i+= 1, salta directamente del bucle, y la declaración en el tiempo que no se ejecutará).
Compilación del segundo ejemplo (solo se selecciona el método principal):
Public static void main (java.lang.string []); Descriptor: ([lJava/lang/string;) v Flags: acc_public, ACC_static Code: stack = 2, locals = 2, args_size = 1 0: bipush 100 // 100 push stack 2: istore_1 // guardar en el segundo var local (el primer var local es el parámetro de método) 3: iload_1 // cargar 4 de la segunda var: iinc de la valora local. Posición 2 de VAR local (la variable local aumenta, el resultado todavía está en el VAR local, el top 1 de la pila de operandos no cambiará) 7: Bipush 100 // 100 Push PIST 9: IF_ICMPle 15 // Compare los dos valores enteros int en la parte superior de la pila de operando, si el primero es menos que o igual a la segunda, salte a la línea 15: goto 25 // de otra manera 25 (salta de otra manera. 1> Pila de operando Top 2) 15: Getstatic #2 // Field java/lang/system.out: ljava/io/printstream; 18: ILOAD_1 // // CARGAR DEL EL PRIMERO VAR LOCAL 19: InvokeVirtual #3 // Método java/io/printstream.println: (i) v // Llame a este método 22: goto 3 // salta a 3 nuevamente, bucle nuevamente 25: return // salga
El tercer ejemplo:
prueba de paquete; public class plus_test03 {static int proplus () {int i = 55; int j = ++ i; regresar j; // 56} static int postplus () {int i = 55; int j = i ++; regresar j; // 55} public static void main (String [] args) {System.out.println (proplus ()); // 56 System.out.println (postplus ()); // 55}}Compilación del tercer ejemplo:
static int proplus (); descriptor: ()I flags: ACC_STATIC Code: stack=1, locals=2, args_size=0 0: bipush 55 //55 stack 2: istore_0 //Storage the top of the int stack to the first local var 3: iinc 0, 1 //The first local var plus 1 6: iload_0 //Load from local var 7: istore_1 //Save to the second local var 8: ILOAD_1 // La parte superior de la pila es la segunda var 9 local: Ireturnstatic int postplus (); Descriptor: () I Flags: Acc_static Code: stack = 1, locals = 2, args_size = 0 0: bipush 55 2: istore_0 3: iload_0 // cargar a la pila 4: iinc 0, 1 // el primer var local más 1 7: istore_1 8: iload_1: ireturn
Se puede ver que la diferencia entre la parte delantera ++ y la parte trasera ++ es la parte azul anterior (// el primer var local Var más 1), que son lo contrario. Para el predecesor, el número en el VAR local se agregará 1 y luego se cargará en la pila, mientras que este último se cargará desde la pila VAR local a la pila, y luego el VAR local se agregará 1, que es equivalente a dejar una copia de seguridad.
en conclusión:
uno. La posición previa y la posición post-posición ++ agregan 1 al valor variable primero, en lugar de agregar 1 al preposición ++ y luego calcular, mientras que el post-posición ++ primero y luego calculando.
dos. Desde un habla programática, el post-++ primero asigna la variable a una variable temporal, luego agrega el valor de la variable por 1 y luego usa la variable temporal para participar en la operación.
tres. Desde el punto de vista de instrucción, el valor de la variable se empuja a la pila antes de ejecutar la instrucción de valor agregado (IINC). Después de ejecutar la instrucción de valor agregado, se utiliza el valor presionado en la pila.
Espero que a través de este artículo, comprenda a fondo la diferencia entre las operaciones pre-postes ++ y post-posición ++. ¡Gracias por su apoyo para este sitio!