Es wird allgemein angenommen, dass die Vorposition ++ zuerst den Wert der Variablen zu 1 hinzufügt und dann den Wert nach dem Hinzufügen von 1 zur Teilnahme an der Operation verwendet. Während die Post-Position ++ zuerst den Wert verwendet, um an der Operation teilzunehmen, und dann den Wert zu 1 hinzugefügt.
Schauen wir uns das erste Beispiel an:
Pakettest; public class plus_test01 {public static void main (String [] args) {int i = 100; i = i ++; System.out.println (i); }}Ratet mal, was das Ergebnis ist?
Schauen wir uns die zweite an:
Pakettest; public class plus_test02 {public static void main (String [] args) {int k = 100; while (true) {if (k ++> 100) {// system.out.println (k); brechen; } System.out.println (k); }}}Ratet mal, was das Ergebnis ist?
Unabhängig davon, ob es sich vor-++ oder nach-++ handelt, wird der Wert der Variablen zunächst um 1 erhöht, bevor sie weiter berechnet werden. Die reale Differenz zwischen den beiden ist: Das Pre-++ fügt den Wert der Variablen um 1 hinzu und verwendet den Mehrwert, um Berechnungen durchzuführen, während der Post-++ zuerst die Variable einer temporären Variablen zuweist, 1 zum Wert der Variablen fügt und dann die temporäre Variable verwendet, um Berechnungen durchzuführen.
Für den folgenden Code -Snippet (Präfix ++):
int i = 1;
int j = ++ i*5;
Tatsächlich entspricht der zweite Satz:
i+= 1; // füge i zu 1 hinzu
J = I*5; // Berechnen Sie den Wert nach dem Hinzufügen von 1 damit das Ergebnis: 10
Und für den folgenden Code-Snippet (Post-++):
int i = 1;
int j = i ++*5;
Der zweite Satz entspricht:
int temp = i; // Ich zuweisen eine vorübergehende Variable
i+= 1; // füge i zu 1 hinzu
j = temp*5; // Berechnen Sie die temporäre Variable damit, das Ergebnis ist: 5
Für das erste Beispiel entspricht es:
int temp = i;
i+= 1;
i = temp; //
Das Ergebnis sollte also unverändert sein, dh 100.
Der Montagecode für das erste Beispiel lautet:
Public Static Void Main (Java.lang.String []); Deskriptor: ([Ljava/Lang/String;) V Flags: ACC_PUBLIC, ACC_STATISCHE CODE: STACK = 2, LOCALALS = 2, args_size = 1 0: bipush 100 2: istore_1 3: iload_1 4: iinc 1, 1 // Die zweite in lokaler var plus 1 7: isTore_1 //. java/lang/system.out: ljava/io/printstream; 11: iload_1 // Der geladene Parameter ist der zweite im Stapel, dh es ist immer noch 100 12: InvokeVirtual #22 // Methode Java/IO/Printstream.println: (i) V 15: Rückgabe
Für das zweite Beispiel ist es eigentlich nicht schwierig, aber das Ergebnis ist 101. Achten Sie auf den Prozess und Sie können solche Fehler in Zukunft nicht machen. (Der Vorgang lautet: Vergleiche Temp = i, temp> 100, offensichtlich nicht wahr. Überspringen Sie i+= 1 mit dem SYSO -Satz, natürlich drucken Sie 101, Schleife erneut, und es gibt auch temp = i, temp> 100, diesmal ist es wahr und dann i+= 1, springt direkt aus der Schleife, und die Aussage wird in der Zeit nicht ausgeführt.)
Zusammenstellung des zweiten Beispiels (nur die Hauptmethode wird ausgewählt):
Public Static Void Main (Java.lang.String []); Deskriptor: ([Ljava/Lang/String;) V -Flags: ACC_PUBLIC, ACC_STATISCHE CODE: STACK = 2, LOCALALS = 2, args_size = 1 0: bipush 100 // 100 Push Stack 2: istore_1 // Auf dem zweiten Lokal -Var -Var -Var -Var -Var -Var -Vari. Position 2 der lokalen VAR (die lokale Variable erhöht sich, das Ergebnis befindet sich immer noch in der lokalen VAR, die obere 1 des Operandenstapels ändert sich nicht) 7: Bipush 100 // 100 Push -Stapel 9: if_icmple 15 // Vergleichen 1> Operand Stack Top 2) 15: GetStatic #2 // Feld Java/Lang/System.out: Ljava/io/printstream; 18: iload_1 // // laden aus dem ersten lokalen var 19: invokevirtual #3 // Methode Java/io/printstream.println: (i) v // nennen
Das dritte Beispiel:
Pakettest; public class plus_test03 {static int proplus () {int i = 55; int j = ++ i; Rückkehr J; // 56} static int postPlus () {int i = 55; int j = i ++; Rückkehr J; // 55} public static void main (String [] args) {System.out.println (priplus ()); // 56 system.out.println (postplus ()); // 55}}Zusammenstellung des dritten Beispiels:
static int proplus (); Deskriptor: () i Flags: ACC_STATISCH CODE: STACK = 1, LOCALS = 2, Args_Size = 0 0: Bipush 55 // 55 Stack 2: istore_0 // Speichern Sie die Oberseite des Int -Stacks auf den ersten lokalen Var 3: iinc 0, 1 // Die ersten lokalen VAR -VAR -VAR -VAR -VAR -VAR -VAR -VAR 8: LOCOD: // Die Oberseite des Stapels ist der zweite lokale VAR 9: Ireturnstatic int postPlus (); Deskriptor: () I Flags: ACC_STATISCH CODE: STACK = 1, LOCALS = 2, Args_Size = 0 0: Bipush 55 2: iStore_0 3: iload_0 // laden Sie in Stack 4: iinc 0, 1 // Der erste lokale Var plus 1 7: istore_1 8: iload_1 9: ireturn
Es ist ersichtlich, dass der Unterschied zwischen vorne ++ und dem hinteren ++ der blaue Teil oben ist (// der erste lokale var plus 1), die das Gegenteil sind. Für den Vorgänger wird die Zahl in der lokalen VAR hinzugefügt und dann in den Stapel geladen, während letzteres vom Stapel lokalen VAR zum Stapel geladen wird und der lokale VAR 1 hinzugefügt wird, was dem Verlassen einer Sicherung entspricht.
abschließend:
eins. Die Vorposition und die Postposition ++ hinzufügen zuerst 1 zum variablen Wert, anstatt 1 zur Pre-Position ++ und dann zu berechnen, während die Postposition ++ zuerst und dann berechnet.
zwei. Aus programmgesteuertem Vorgang weist der Post-++ zuerst die Variable einer temporären Variablen zu, fügt dann den Wert der Variablen um 1 hinzu und verwendet dann die temporäre Variable, um am Vorgang teilzunehmen.
drei. Aus Sicht der Anweisung wird der Wert der Variablen auf den Stapel gedrückt, bevor der Wertschöpfungsanweis (IINC) ausgeführt wird. Nach der Ausführung der Wertschöpfungsanweisung wird der auf den Stapel gedrängte Wert verwendet.
Ich hoffe, dass ich durch diesen Artikel den Unterschied zwischen Vorposition ++ und Post-Position ++ -Operationen gründlich verstehen werde. Vielen Dank für Ihre Unterstützung für diese Seite!