Zykluskontrolle
Es kann eine Situation geben, in der wir mehrmals Codeblöcke ausführen müssen, was normalerweise als Schleife bezeichnet wird.
Java hat einen sehr flexiblen Mechanismus mit drei Schleifen. Eine der folgenden drei Schleifen kann verwendet werden:
Ab Java 5 wird eine erweiterte Schleife eingeführt. Dies wird hauptsächlich für Arrays verwendet.
Während der Schleife
Während Schleife eine Kontrollstruktur ist, die eine bestimmte Anzahl von Aufgaben wiederholen kann.
Grammatik
Die Syntax von einer Weile ist:
while (boolean_expression) {// Anweisungen}Bei der Ausführung werden die Aktionen in der Schleife ausgeführt, wenn das Ergebnis des booleschen Ausdrucks wahr ist. Solange das Ergebnis des Ausdrucks wahr ist, wird die Ausführung fortgesetzt.
Hier ist der wichtigste Punkt der WHOR -Schleife, dass die Schleife möglicherweise nicht für immer läuft. Wenn der Ausdruck getestet wird, ist das Ergebnis falsch, der Schleifenkörper wird übersprungen und die erste Aussage nach der WHOS -Schleife wird ausgeführt.
Beispiel
public class test {public static void main (String args []) {int x = 10; while (x <20) {System.out.print ("Wert von x:" + x); x ++; System.out.print ("/n"); }}}Dies führt zu den folgenden Ergebnissen:
Wert von x: 10 Wert von x: 11 Wert von x: 12 Wert von x: 13 Wert von x: 14 VValue von x: 15 Wert von x: 16 Wert von x: 17 VVALUE von x: 18 VValue von x: 19
Tu ... während Schleife
tun ... während die Schleife einer Weile ähnlich ist, außer dass eine Do ... während die Schleife mindestens einmal ausgeführt wird.
Grammatik
Die Syntax eines Do ... während die Schleife lautet:
do {// Anweisungen} while (boolean_expression);Beachten Sie, dass der boolesche Ausdruck am Ende der Schleife erscheint, sodass die Anweisung in der Schleife den vorherigen booleschen Test durchführt.
Wenn der boolesche Ausdruck wahr ist, springt der Steuerfluss zurück und die Anweisung in der Schleife wird erneut ausgeführt. Dieser Vorgang wird wiederholt, bis der boolesche Ausdruck falsch ist.
Beispiel
public class test {public static void main (String args []) {int x = 10; do {System.out.print ("Wert von x:" + x); x ++; System.out.print ("/n"); } while (x <20); }}Dies führt zu den folgenden Ergebnissen:
Wert von x: 10 Wert von x: 11 Wert von x: 12 Wert von x: 13 Wert von x: 14 VValue von x: 15 Wert von x: 16 Wert von x: 17 VVALUE von x: 18 VValue von x: 19
Für Schleife
Die für die Schleife ist eine Schleifenkontrollstruktur, die eine bestimmte Anzahl von Male effektiv schreiben kann, die ausgeführt werden muss.
Wenn Sie wissen, wie oft eine Aufgabe wiederholt werden muss, ist eine für die Schleife von Vorteil.
Grammatik
Die Syntax von A for Loop ist:
für (Initialisierung; boolean_expression; update) {// Anweisungen}Das Folgende ist der Steuerungsprozess von A for Loop:
Der Initialisierungsschritt wird zuerst und nur einmal durchgeführt. Dieser Schritt deklariert und initialisiert alle Schleifensteuerungsvariablen. Es besteht keine Notwendigkeit, hier eine Erklärung abzulegen, nur ein Semikolon muss erscheinen.
Als nächstes bewertet der boolesche Ausdruck. Wenn wahr, wird der Schleifenkörper ausgeführt. Wenn es falsch ist, wird der Schleifenkörper nicht ausgeführt, und die Prozessregelung wird zur nächsten Anweisung über die für die für die Loop verlaufende Anweisung springen.
Danach springt der Steuerprozess, wenn der Schleifenkörper für die Schleife ausgeführt wird, zur Sicherung zur Aktualisierungsrechnung. Diese Anweisung ermöglicht Aktualisierungen aller Schleifensteuerungsvariablen. Diese Aussage kann leer gelassen werden, solange ein Semikolon nach einem booleschen Ausdruck erscheint.
Der boolesche Ausdruck bewertet nun die Berechnung erneut. Wenn wahr ist, führen Sie den Vorgang aus und wiederholen Sie den Vorgang (Schleifenkörper, dann aktualisieren Sie die Schritte, dann booleschen Ausdruck). Danach ist der boolesche Ausdruck falsch, der Schleifen endet.
Beispiel
public class test {public static void main (String args []) {für (int x = 10; x <20; x = x + 1) {System.out.print ("Wert von x:" + x); System.out.print ("/n"); }}}Dies führt zu den folgenden Ergebnissen:
Wert von x: 10 Wert von x: 11 Wert von x: 12 Wert von x: 13 Wert von x: 14 VValue von x: 15 Wert von x: 16 Wert von x: 17 VVALUE von x: 18 VValue von x: 19
Neue Funktionen für Schleifen in Java
Ab Java 5 wird eine erweiterte Schleife eingeführt. Dies wird hauptsächlich für Arrays verwendet.
Grammatik
Die Syntax für die Verbesserung für die Schleife lautet:
für (Deklaration: Ausdruck) {// Anweisungen}Deklaration: Neue Erklärungen einer Blockvariable, eine Variable, die mit den Elementen im Array kompatibel ist. Die Variable kann innerhalb des für den Blocks und dessen Wertes verwendet werden, da das aktuelle Array -Element gleich ist.
Ausdruck: Für dieses Berechnungsergebnis muss ein Schleifenarray abgeschlossen werden. Ein Ausdruck kann eine Array -Variable oder ein Methodenaufruf sein, der ein Array zurückgibt.
Beispiel
public class test {public static void main (String args []) {int [] numbers = {10, 20, 30, 40, 50}; für (int x: number) {System.out.print (x); System.out.print (","); } System.out.print ("/n"); String [] names = {"James", "Larry", "Tom", "Lacy"}; für (Zeichenfolge Name: Namen) {System.out.print (Name); System.out.print (","); }}}Dies führt zu den folgenden Ergebnissen:
10, 20, 30, 40, 50, James, Larry, Tom, Lacy,
Keywords brechen
Mit dem Schlüsselwortunterbrechung wird die gesamte Schleife gestoppt. Das Schlüsselwort für Break muss in jeder Schleife oder in einer Switch -Anweisung verwendet werden.
Der Keyword -Pause stoppt die Ausführung der innersten Schleife und beginnt mit der Ausführung der nächsten Codezeile nach dem Block.
Grammatik
Break Syntax ist eine separate Anweisung in jeder Schleife:
Kopieren Sie den Code wie folgt: Brechen Sie brechen
Beispiel
public class test {public static void main (String args []) {int [] numbers = {10, 20, 30, 40, 50}; für (int x: number) {if (x == 30) {break; } System.out.print (x); System.out.print ("/n"); }}}Dies führt zu den folgenden Ergebnissen:
1020
Setzen Sie Keywords fort
Das Continu -Schlüsselwort kann in der Kontrollstruktur eines beliebigen Links verwendet werden. Es führt dazu, dass die Schleife sofort zur nächsten Iteration der Schleife springt.
In einer für die Schleife führt das Keyword von Fortsetzung dazu, dass der Steuerfluss sofort zur Update -Anweisung springt.
In einer Weile oder in der Schleife springt der Steuerfluss sofort zum booleschen Ausdruck.
Grammatik
Die Fortsetzung der Syntax ist eine separate Anweisung in jeder Schleife:
Kopieren Sie den Code wie folgt: Fahren Sie fort
Beispiel
public static void main (String args []) {int [] numbers = {10, 20, 30, 40, 50}; für (int x: numbers) {if (x == 30) {Fortsetzung; } System.out.print (x); System.out.print ("/n"); }}}Dies führt zu den folgenden Ergebnissen:
10204050
Bedingte Urteilsvermögen
In Java gibt es zwei Arten von bedingten Beurteilungsaussagen, nämlich:
Wenn Aussage:
Eine IF -Aussage besteht aus einem booleschen Ausdruck, gefolgt von einer oder mehreren Aussagen.
Grammatik
Die Syntax einer IF -Aussage lautet:
if (boolean_expression) {// Aussagen werden ausgeführt, wenn der boolesche Ausdruck wahr ist}}Wenn der Wert des booleschen Ausdrucks wahr ist, wird der Block, wenn Anweisung im Code ausgeführt wird. Wenn nicht wahr, wird der erste Codesatz nach dem Ende der IF -Anweisung (nach Klammern) ausgeführt.
Beispiel
public class test {public static void main (String args []) {int x = 10; if (x <20) {System.out.print ("Dies ist, wenn Anweisung"); }}}Dies führt zu den folgenden Ergebnissen:
Dies ist, wenn Aussage
Wenn ... sonst Aussage
Jede Anweisung kann von einer optionalen Anweisung folgen. Wenn der boolesche Ausdruck falsch ist, wird die Aussage ausgeführt.
Grammatik
Die Syntax von if ... sonst ist:
if (boolean_expression) {// führt aus, wenn der boolesche Ausdruck wahr ist} else {// wird ausgeführt, wenn der boolesche Ausdruck falsch ist}Beispiel
public class test {public static void main (String args []) {int x = 30; if (x <20) {System.out.print ("Dies ist, wenn Anweisung"); } else {system.out.print ("this ist sonst Anweisung"); }}}Dies führt zu den folgenden Ergebnissen:
Dies ist sonst eine Aussage
wenn ... sonst wenn ... sonst Anweisung
Wenn kann ein optionaler anderer Anweisung folgt. Es ist sehr nützlich, eine einzelne If -Aussage und eine andere IF -Anweisung unter verschiedenen Bedingungen zu testen.
Es gibt einige Punkte zu beachten, wenn es verwendet wird, wenn, sonst wenn, sonst Anweisungen.
Grammatik
Die Syntax von if ... sonst ist:
if (boolean_expression 1) {// führt aus, wenn der boolesche Ausdruck 1 wahr ist} else if (boolean_expression 2) {// führt aus, wenn der boolesche Ausdruck 2 wahr ist} else if (boolean_expression 3) {// wird ausgeführt, wenn der booleanische Ausdruck 3 wahr ist}} else {//.Beispiel
public class test {public static void main (String args []) {int x = 30; if (x == 10) {System.out.print ("Wert von x ist 10"); } else if (x == 20) {System.out.print ("Wert von x ist 20"); } else if (x == 30) {System.out.print ("Wert von x ist 30"); } else {system.out.print ("this ist sonst Anweisung"); }}}Dies führt zu den folgenden Ergebnissen:
Der Wert von x ist 30
Verschachtelt, wenn ... sonst Aussage
Es ist immer eine legale verschachtelte IF-ELSE-Erklärung, was bedeutet, dass Sie eine if oder sonst eine Anweisung in einer anderen wenn oder wenn Anweisung verwenden können.
Grammatik
Die Syntax von verschachtelt, wenn ... sonst wie folgt ist:
if (boolean_expression 1) {// führt aus, wenn der boolesche Ausdruck 1 wahr ist if (boolean_expression 2) {// führt aus, wenn der boolesche Ausdruck 2 wahr ist}}Weil wir, wenn Aussagen verschachtelt sind, können wir sonst nisten, wenn ... sonst auf ähnliche Weise.
Beispiel
public class test {public static void main (String args []) {int x = 30; int y = 10; if (x == 30) {if (y == 10) {System.out.print ("x = 30 und y = 10"); }}}}Dies führt zu den folgenden Ergebnissen:
X = 30 und y = 10
Schaltanweisung
Die Switch -Anweisung ermöglicht es einer Variablen, eine Reihe von Gleichheit von Wert zu testen. Jeder Wert wird als Fall bezeichnet, und die zu Beginn der Variablen werden auf jeden Fall überprüft.
Grammatik
Die Syntax für verstärkte für Schleifen lautet:
Switch (Ausdruck) {Fall Value: // Anweisungen Break; // Optionaler Fallwert: // Anweisungen Break; // Optional // Sie können eine beliebige Anzahl von Fallanweisungen haben. Standard: // Optional // Anweisungen}Die folgenden Regeln gelten für Switch -Anweisungen:
Beispiel
public class test {public static void main (String args []) {// char grade = args [0] .charat (0); char grade = 'c'; switch (grade) {case 'a': system.out.println ("ausgezeichnet!"); brechen; Fall 'B': Fall 'C': System.out.println ("gut gemacht"); brechen; Fall 'D': System.out.println ("du bestanden"); Fall 'F': System.out.println ("Besser versuchen"); brechen; Standard: System.out.println ("Ungültige Note"); } System.out.println ("Ihre Note ist" + grade); }}Kompilieren und führen Sie das obige Programm aus, das verschiedene Befehlszeilenparameter verwendet. Dies führt zu den folgenden Ergebnissen:
$ java testwell erledigt Ihre Note ist ein c