1. kreisförmige Struktur
Eine Schleifenanweisung kann wiederholt einen bestimmten Code ausführen, wenn die Schleifenbedingung erfüllt ist. Dieser wiederholte Code wird als Schleifenkörperanweisung bezeichnet. Wenn diese Schleifenbehörde wiederholt ausgeführt wird, muss die Bedingung für Schleifenbeurteilungen zum richtigen Zeitpunkt auf False geändert werden, um die Schleife zu beenden. Andernfalls wird die Schleife weiter ausgeführt und bilden eine tote Schleife.
Zusammensetzung von Schleifenaussagen:
Initialisierungsanweisung: Eine oder mehrere Aussagen, diese Aussagen vervollständigen einige Initialisierungsvorgänge.
Entscheidungsbedingte Aussage: Dies ist ein boolescher Ausdruck, der bestimmen kann, ob die Schleifenkörper ausgeführt werden sollen.
Schleifen-Körper-Aussage: Dieser Teil ist eine Schleifenkörperanweisung, die wir oft tun müssen.
Anweisung der Kontrollbedingung: Dieser Teil wird ausgeführt, bevor die Bedingung des nächsten Zyklusurteils nach dem Ende des Zykluskörpers ausgeführt wird. Durch Steuerung der Variablen im Schleifenbedingung endet die Schleife zum richtigen Zeitpunkt.
EG: Wenn "HelloWorld" 10 Mal auf der Konsole ausgegeben wird,
Initialisierungsanweisung: Definieren Sie die Initialisierung als zum ersten Mal.
Urteilsbedingte Aussage: Die Anzahl der Male darf das 10 -fache darf.
Schleifenkörperanweisung: Ausgabe der Aussage "HelloWorld".
Anweisung der Steuerbedingung: Die Anzahl der Zeiten ändert sich zum nächsten Mal.
2. Schleifenstruktur (für Schleifenanweisung)
Für Schleifenanweisungsformat:
für (Initialisierungserklärung; Beurteilung der bedingten Aussage; Kontrollbedingte Aussage) {
Schleifenkörperaussage;
}
Ausführungsprozess:
A: Führen Sie die Initialisierungsanweisung aus
B: Führen Sie die bedingte Aussage aus, um festzustellen, ob das Ergebnis wahr oder falsch ist: Wenn es falsch ist, endet die Schleife; Wenn es wahr ist, führen Sie weiter aus.
C: Schleifenkörperanweisung ausführen
D: Ausführen der Steuerungsbedingung Anweisung ausführen
E: Gehen Sie zurück zu B und fahren Sie fort
Flussdiagramm:
Anmerkungen:
(1) Das Ergebnis der bedingten Erklärung des Urteils ist ein boolescher Typ
(2) Wenn es sich bei der Schleifenanweisung um eine einzige Aussage handelt, können die Zahnspangen weggelassen werden. Wenn es sich um mehrere Aussagen handelt, können die Zahnspangen nicht weggelassen werden. Es wird empfohlen, es nicht wegzulassen.
(3) Im Allgemeinen: Wenn es eine linke Klammer gibt, gibt es kein Semikolon, wenn es ein Semikolon gibt, gibt es keine linke Klammer.
Beispielcode:
1. Ermitteln Sie die Summe der gleichmäßigen Zahlen zwischen 1-100:
/* Anforderungen: A: Finden Sie die Summe von 1-100. B: Finden Sie die Summe gleicher Zahlen zwischen 1-100*/Klasse Fortest1 {public static void main (String [] args) {// Finden Sie die Summe von 1-100. int sum1 = 0; für (int x = 1; x <= 100; x ++) {sum1+= x; } System.out.println ("1-100 ist:"+sum1); System.out.println ("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- // Methode 2 int sum3 = 0;2. Finden Sie das Fakultät von 5:
/* Anforderung: Finden Sie das Faktor von 5. Was ist faktorial? N! = n*(n-1)! Regel n! = n*(n-1)*(n-2)*...*3*2*1 Summe Ideologie. Finden Sie faktorielle Gedanken. */class Fortest2 {public static void main (String [] args) {// Definieren Sie die endgültige Ergebnisvariable int jc = 1; // Das X hier kann tatsächlich direkt mit 2 // für (int x = 1; x <= 5; x ++) für (int x = 2; x <= 5; x ++) {jc *= x; } System.out.println ("1-5 faktorial ist:"+jc); }}3. Ausgabe aller "Narcissus -Nummer" in der Konsole:
/* Anforderungen: Ausgabe aller "Narzissusnummern" in der Konsolenanalyse: Wir wissen nicht, was "Narzissnummern" ist. Was bitten Sie mich, zu tun? Die sogenannten Narzissusnummern beziehen sich auf eine dreistellige Zahl, und die Würfelsumme ihrer Ziffern entspricht der Zahl selbst. Zum Beispiel: 153 ist eine Narzissen. 153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153 A: Die dreistellige Zahl zeigt uns tatsächlich den Bereich an. B: Durch die For -Loop können wir jede dreistellige Anzahl erhalten, aber das Problem ist, wie die Daten dieser dreistelligen Zehn und Hunderte erhalten werden können. Wie erhalten wir die Daten von zehn und Hunderten von Daten? Angenommen, es gibt Daten: 153 Ge: 153%10 = 3 SHI: 153/10%10 = 5 BAI: 153/10/10%10 = 1 Qian: x/10/10/10%10 Wan: x/10/10/10/10%10 ... c: let Ge*Ge*Ge+SHI*SHI*SHI+BAI*BAI*BAI*BAI -BAI -BAI -BAI -BAI -BAI -BAI -BAI -BAI -BAI -BAI -BAI -LATE MIT DIE DATEN UND AUSSERHALTEN. */class Fortest3 {public static void main (String [] args) {// Die dreifache Ziffer sagt uns tatsächlich den Bereich. für (int x = 100; x <1000; x ++) {int ge = x%10; int Shi = x/10%10; int bai = x/10/10%10; // GE*Ge*Ge+Shi*shi*shi+bai*bai*bai mit den Daten vergleiche if (x == (Ge*Ge*Ge+shi*shi*shi+bai*bai)) {// Wenn dieselben, geben Sie die Daten auf der Konsole aus. System.out.println (x); }}}}3. Schleifenstruktur (während Schleifenanweisung)
Während Schleifenanweisungsformat:
while (Urteilsbedingte Aussage) {
Schleifenkörperaussage;
}
// Aussage für erweiterte Formatinitat;
while (Urteilsbedingte Aussage) {
Schleifenkörperaussage;
Steuerungserklärung;
}
Flussdiagramm:
Der Unterschied zwischen A für Schleife und einer Weile Schleife:
Bei Schleifenanweisungen und während Schleifenanweisungen äquivalent konvertiert werden können, es gibt jedoch noch einige kleine Unterschiede.
(1) Nutzungsunterschiede:
Auf die von der steuerbedingte Anweisung kontrollierte Variable kann nach dem Ende der Loop nicht zugegriffen werden und kann nach dem WHE -Schleifenenden weiterhin verwendet werden. Wenn Sie es weiterhin verwenden möchten, verwenden Sie es, während es sonst empfohlen wird. Der Grund dafür ist, dass die für die Schleife endet und die Variable aus dem Speicher verschwindet, was die Effizienz der Speicherverwendung verbessern kann.
(2) Szenenunterschied:
Für die Schleife eignet sich für einen Bereich für ein Reichweite, während die Schleife für den Betrieb für eine unklare Anzahl von Urteilen geeignet ist
Beispielcode:
Der höchste Berg in unserem Land ist Mount Everest: 8848m. Ich habe jetzt ein groß genuges Papier mit einer Dicke von: 0,01 m. Darf ich fragen, wie oft ich es falte, um sicherzustellen, dass die Dicke nicht niedriger ist als die Höhe des Mount Everest?
/* Der höchste Berg in unserem Land ist Mount Everest: 8848m. Ich habe jetzt ein groß genuges Papier mit einer Dicke von: 0,01 m. Darf ich fragen, wie oft ich faltete, kann ich sicherstellen, dass die Dicke nicht niedriger ist als die Höhe des Mount Everest? Analyse: A: Definieren Sie eine statistische Variable, der Standardwert ist 0 B: Der höchste Peak ist der Mount Everest: 8848M Dies ist die endgültige Dicke. Ich habe jetzt ein groß genuges Stück Papier, mit einer Dicke von: 0,01 m. Dies ist die anfängliche Dicke C: Wie oft kann ich sicherstellen, dass die Dicke nicht niedriger ist als die Höhe des Mount Everest? Welche Änderungen werden passieren, wenn ich es einmal faltete? Das heißt, die Dicke ist doppelt so dick wie zuvor. D: Solange die Dicke jeder Änderung die Höhe des Mount Everest nicht überschreitet, wird sie gefaltet, statistische Variable ++ E: Ausgangsstatistische Variablen. */class whiletest01 {public static void main (String [] args) {// eine statistische Variable definieren, der Standardwert ist 0 int count = 0; // Der höchste Gipfel ist der Mount Everest: 8848m Dies ist die endgültige Dicke // Ich habe jetzt ein Papier, das groß genug ist, mit einer Dicke von 0,01 m Dies ist die anfängliche Dicke // zum Einfachheit halber habe ich 0,01 in 1 verwandelt, und so wie 8848 884800 int Ende = 884800 wurde; int start = 1; Während (Start <end) {//, solange die Dicke jeder Änderung die Höhe des Mount Everest nicht überschreitet, falten Sie sie und die statistische Variable ++ Count ++; // Welche Änderungen werden passieren, wenn es einmal gefaltet ist? Es ist so, dass die Dicke doppelt so groß ist. Start *= 2; System.out.println ("Th"+count+"Dicke"+start); } // statistische Variablen ausgeben. System.out.println ("gestapelt werden"+count+"time"); }}4. Schleifenstruktur (tun Sie… während Schleifenanweisung)
Grundformat:
Tun {
Schleifenkörperaussage;
} while ((Urteilsbedingte Anweisung); [/Code]
Erweitertes Format:
Initialisierungsaussage;
Tun {
Schleifenkörperaussage;
Steuerungserklärung;
} while ((Urteilsbedingte Anweisung); [/Code]
Flussdiagramm:
5. Unterschiede und Vorsichtsmaßnahmen für die zyklische Struktur:
Die drei Schleifenanweisungen können tatsächlich dieselbe Funktion erfüllen, was bedeutet, dass sie äquivalent umwandeln können, aber es gibt immer noch kleine Unterschiede:
Die Do… während die Schleife den Schleifenkörper mindestens einmal ausführen. Für Schleife und während die Schleife nur den Schleifenkörper ausführen, wenn der Zustand wahr ist
1. Anmerkungen:
Beim Schreiben von Programmen sollten Sie der für die für die Schleife Priorität einräumen, dann die WHOR -Schleife in Betracht ziehen und schließlich das DO ... während der Schleife in Betracht ziehen.
Der folgende Code ist eine tote Schleife:
while (wahr) {}
für(;;){}
2. verschachtelte Verwendung von Schleifen: Der Schleifenkörper der Schleifenaussage selbst ist eine Schleifenanweisung
(1) Frage 1: Bitte geben Sie ein Stern -Muster mit 4 Zeilen und 5 Spalten aus:
Tipp: Die Anzahl der von der äußeren Schleife gesteuerten Zeilen und die Anzahl der von der inneren Schleife gesteuerten Spalten
/*Anforderungen: Bitte geben Sie die folgende Form aus. Spalten für (int x = 0; x <5; x ++) {für (int y = 0; y <5; y ++) {System.out.print ("*"); } System.out.println (); } System.out.println("---------------------------------------------------------); //We have implemented a shape of 5 rows and 5 columns//But this is not what we want //What we want is the change of the number of columns//How does the number of columns change? //The first row: 1 column y=0,y<=0,y++ //The second row: 2 column y = 0, y <= 1, y ++ // Die dritte Zeile: 3 Spalte y = 0, y <= 2, y ++ // Die vierte Zeile: 4 Spalte y = 0, y <= 3, y ++ // Die fünfte Zeile: 5 Spalte y = 0, y <= 4, y ++ // Wenn die Veränderung des OUTER -SOOP -Prograges nachgeschaut wird, wird das OUTER -SOOP. für (int x = 0; x <5; x ++) {für (int y = 0; y <= x; y ++) {System.out.print ("*");(2) Frage 2: Ausgabe der neun-neun-Multiplikationstabelle auf der Konsole:
/* Anforderungen: Ausgabe der neun-neun-Multiplikationstabelle in der Konsole. First we write the nine-nine multiplication table: 1*1=1 1*2=2 2*2=4 1*3=3 2*3=6 3*3=9 1*4=4 2*4=8 3*4=12 4*4=16 ... 1*9=9 2*9=18 3*9=27 ... Let's first see this nine-nine multiplication table as such: * ** ********* ********* ********* ********* ********* '/t' Die Position eines Registerkartenzeichens (Tabtab -Schlüssel) '/r' Eingaber '/n' Zeilenumbruch */class forfortest02 {public static void main (string [] args) {für (int x = 0; x <9; x ++) {für (int y = 0; y <= x; y ++) {out.Print.print (" *); } System.out.println (); } System.out.println ("----------------------"); // Um Daten zu verwenden, beginnen wir mit 1 für (int x = 1; x <= 9; x ++) {for (int y = 1; y <= x; y ++) {System.out.print (y+"*"+x+"="+y*x+"/t"); } System.out.println (); }}}Laufeffekt:
6. Jump Control Anweisung:
Wie wir bereits bereits gesagt haben, ist Goto in Java ein reserviertes Wort und kann derzeit nicht verwendet werden. Obwohl es keine Goto -Erklärung gibt, um die Sicherheit des Programms zu verbessern, bringt es auch viele Unannehmlichkeiten mit sich. Zum Beispiel möchte ich enden, wenn eine bestimmte Schleife zu einem bestimmten Schritt weiß, und ich kann das jetzt nicht tun. Um diesen Defekt auszugleichen, bietet Java Pause, Fortsetzung und Rückkehr, um Sprünge und Aussagen zu kontrollieren.
Interrupt brechen
weitermachen
zurückkehren
1. Jump Control Anweisung (Pause):
Verwenden Sie Szenarien für die Pause:
~ In der Switch -Anweisung zur Auswahl der Struktur
~ In der Schleifenerklärung (wenn der Schleifenerklärung ein Urteil hinzugefügt wird)
Hinweis: Es ist bedeutungslos, das Verwendungsszenario zu hinterlassen
Die Funktion der Pause:
A: Brechen Sie aus der einschichtigen Schleife aus
B: Brechen Sie aus mehrschichtiger Schleife aus
Um diesen Effekt zu erzielen, müssen Sie etwas wissen. Eine Erklärung mit Etikett. Tagennamen müssen den Java -Namensregeln einhalten
Format:
Tag -Name: Anweisung
Beispielcode:
/* Kontroll -Sprungerklärung: Break: Interrupt Fortsetzung: Weiter: Rückkehr: Return Break: Interrupt Bedeutungsnutzungsszenario: A: Switch -Anweisung B: Schleife Anweisung. (Wenn der Schleifenanweisung ein Urteil hinzugefügt wird) HINWEIS: Es ist bedeutungslos, die beiden oben genannten Szenen zu hinterlassen. Wie benutze ich es? A: Brechen Sie aus einer einschichtigen Schleife B: Brechen Sie aus einer mehrschichtigen Schleife aus, um diesen Effekt zu erzielen. Sie müssen etwas wissen. Eine Erklärung mit Etikett. Format: Tag -Name: Anweisung */Klasse Breakdemo {public static void main (String [] args) {// Offset Outside Switch oder Loop // Break; // eine einschichtige Schleife für (int x = 0; x <10; x ++) {if (x == 3) {break; } System.out.println ("helloWorld"); } System.out.println ("Over"); System.out.println ("---------------"); // Versatz einer Mehrschichtschleife WC: for (int x = 0; x <3; x ++) {nc: for (int y = 0; y <4; y ++) {if (y == 2) {// break nc; WC brechen; } System.out.print ("*"); } System.out.println (); }}}In Zeile 38 fügen wir der äußeren Schleife namens WC ein Tag hinzu und springen dann aus diesem Tag in Zeile 42 heraus.
Laufeffekt:
HINWEIS: In der tatsächlichen Entwicklung ist die Funktion des Springens mehrschichtiger Looping fast unmöglich zu verwenden.
2. Jump Control Anweisung (Weiter):
Verwenden Sie Szenarien zum Fortsetzung:
Es macht keinen Sinn, das Nutzungsszenario in einer Schleifenanweisung zu lassen
Der Unterschied zwischen Fortsetzung und Break:
Break of Break of Ein-Layer-Schleife aus einer Schleife ausbrechen und in die nächste Ausführung eintreten.
Die Effekte sind wie folgt:
Interviewfragen:
für (int x = 1; x <= 10; x ++) {if (x%3 == 0) {// füllen Sie den Code hier aus} System.out.println ("Java -Lernen"); }Füllen Sie Zeile 4 des obigen Codes aus, um die folgenden Bedingungen zu erfüllen:
Ich möchte 2 Mal in der Konsole ausgeben: "Java Learn" -Pause;
Ich möchte 7 Mal in der Konsole ausgeben: "Java Learning" Weiter;
Ich möchte 13 Mal in der Konsole ausgeben: "Java Learning" System.out.println ("Java Learning");
3. Jump Control Anweisung (Rückgabe)
Das Return -Keyword besteht nicht darin, aus dem Schleifenkörper zu springen. Die häufiger verwendete Funktion besteht darin, eine Methode zu beenden, dh eine Methode zu beenden und zu der in der oberen Schicht genannten Methode zu springen.
Um es unverblümt auszudrücken: Die Funktion der Rückkehr besteht darin, die Schleife nicht zu beenden, sondern die Methode zu beenden.
Die Effekte sind wie folgt:
Übungen von Schleifenaussagen in Kombination mit Pause:
Interview Frage: Xiaofangs Mutter gibt ihr 2,5 Yuan pro Tag und sie wird es retten. Wenn dieser Tag jedoch der 5. Tag des Rettung oder ein Vielfaches von 5 ist, wird sie 6 Yuan ausgeben. Wie viele Tage kann Xiaofang es auf 100 Yuan retten.
Code -Implementierung:
/* Anforderungen: Xiaofangs Mutter gibt ihr 2,5 Yuan pro Tag, und sie wird es retten. Wenn dieser Tag jedoch der 5. Tag des Rettung oder ein Vielfaches von 5 ist, wird sie 6 Yuan ausgeben. Wie viele Tage kann Xiaofang es auf 100 Yuan retten. Analyse: A: Xiaofangs Mutter gibt ihr 2,5 Yuan pro Tag, doppelter Tagesmoney = 2,5; B: Sie spart zwei Tage = 0; C: Int DayCount = 1 vom ersten Tag; D: Wie viele Tage wird Xiaofang 100 Yuan retten. Doppelergebnis = 100; E: Wenn dieser Tag der 5. Tag des Sparens oder mehrere von 5 ist, wird sie 6 Yuan ausgeben, was darauf hinweist, dass sie den Wert von Daycount beurteilen muss. Wenn die 5 geteilt ist, wird 6 Yuan abgezogen. Daysum -= 6; Dies impliziert auch ein Problem, dh, wenn es nicht mehreren von 5 Tagen ist, muss das Geld angesammelt werden Daysum += Daymoney; F: Weil ich nicht weiß, wie viele Tage es ist, benutze ich eine tote Schleife. Sobald es 100 Yuan überschreitet, werde ich die Schleife verlassen. */class whiledemo {public static void main (String [] args) {// Das Geld, das jeden Tag gespeichert werden soll, beträgt 2,5 Yuan Double Daymoney = 2,5; // Der Initialisierungswert des Speicherns beträgt 0 double tayum = 0; // Storage int DayCount = 1 vom ersten Tag; // Der endgültige Speicher beträgt nicht weniger als 100 und das int -Ergebnis = 100; // Weil ich nicht weiß, wie viele Tage es ist, benutze ich eine tote Schleife, während (wahr) {// Geld tagetum += Daymoney sammeln; // Sobald es 100 Yuan überschreitet, beende ich die Schleife. if (Daysum> = Ergebnis) {System.out.println ("Insgesamt 100 Yuan in der Gesamtspeicherung ausgeben"); brechen; } if (DayCount%5 == 0) {// verbringen Sie 6 yuan Daysum -= 6; System.out.println ("Things"+DayCount+"Insgesamt einen 6 Yuan ausgeben"); } // Die Anzahl der Tage ändert sich tagelang ++; }}}Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.