Wiederholungen
Ein Prozessor eines Computers, der auf die Ausführung von Befehlen spezialisiert ist, kann in einem modernen Computer über eine Milliarde (Maschinencode-)Befehle pro Sekunde ausführen.
In diesem Abschnitt werden wir uns daran gewöhnen, häufig wiederholten Programmcode mit Hilfe von Schleifen zu schreiben.
Motivieren wir dieVerwendung von Schleifen: Unten finden Sie ein Beispiel für ein Programm, das fünf Zahlen vom Nutzenden abfragt und deren Summe berechnet.
Scanner scanner = new Scanner(System.in);
int sum = 0;
System.out.println("Input a number: ");
sum = sum + Integer.valueOf(scanner.nextLine());
System.out.println("Input a number: ");
sum = sum + Integer.valueOf(scanner.nextLine());
System.out.println("Input a number: ");
sum = sum + Integer.valueOf(scanner.nextLine());
System.out.println("Input a number: ");
sum = sum + Integer.valueOf(scanner.nextLine());
System.out.println("Input a number: ");
sum = sum + Integer.valueOf(scanner.nextLine());
System.out.println("The sum of the numbers is " + sum);Das Programm erfüllt seine Aufgabe, aber nicht elegant. Was wäre, wenn das Programm hundert oder sogar tausend Zahlen lesen und ihre Summe ausgeben müsste? Oder was, wenn es nur drei Zahlen lesen müsste?
Das Problem kann mit einer Schleife gelöst werden, die sowohl die Summe als auch die Anzahl der Lesevorgänge verfolgt. Das Programm, das die Summe von fünf Zahlen ausgibt, sieht nun wie folgt aus:
Scanner scanner = new Scanner(System.in);
int numbersRead = 0;
int sum = 0;
while (true) {
if (numbersRead == 5) {
break;
}
System.out.println("Input number");
sum = sum + Integer.valueOf(scanner.nextLine());
numbersRead = numbersRead + 1;
}
System.out.println("The sum of the numbers is " + sum);Als Nächstes machen wir uns mit Schleifen vertraut.
Schleifen und Endlosschleifen
Eine Schleife besteht aus einem Ausdruck, der bestimmt, ob der Code innerhalb der Schleife wiederholt werden soll, sowie aus einem Block, der den zu wiederholenden Quellcode enthält. Eine Schleife hat die folgende Form:
while (_expression_) {
// Der Inhalt des Blocks, umschlossen von geschweiften Klammern
// Der Block kann eine unbegrenzte Menge an Inhalt enthalten
}Wir verwenden vorerst den Wert true als Ausdruck der Schleife. Auf diese Weise wird die Schleifenausführung immer fortgesetzt, wenn das Programm an den Punkt gelangt, der entscheidet, ob sie wiederholt werden soll. Dies geschieht sowohl beim ersten Eintreffen des Programms am Schleifenausdruck als auch beim Erreichen des Endes des Schleifenblocks.
Die Schleifenausführung erfolgt schrittweise, Zeile für Zeile. Das folgende Programm gibt "unendlich" oft I can program aus.
while (true) {
System.out.println("I can program!");
}Ein Programm, das unendlich läuft, endet nicht von selbst. Eine IDE erlaubt üblicherweise das Programm abzubrechen.
Beenden einer Schleife
Die Schleife kann mit dem Befehl break beendet werden. Wenn der Computer den Befehl break ausführt, wird die Programmausführung zum nächsten Befehl nach dem Schleifenblock fortgesetzt.
Im folgenden Beispiel handelt es sich um ein Programm, das die Zahlen von eins bis fünf ausgibt. Beachten Sie, dass die innerhalb der Schleife verwendete Variable vor der Schleife definiert wird. So kann die Variable innerhalb der Schleife inkrementiert werden und die Änderung bleibt zwischen den Schleifendurchläufen bestehen.
int number = 1;
while (true) {
System.out.println(number);
if (number >= 5) {
break;
}
number = number + 1;
}
System.out.println("Ready!");1 2 3 4 5 Ready!
Das Beenden der Schleife erfolgt, wenn eine spezifische Eingabe vom Nutzenden erfolgt oder wenn eine in der Schleife durchgeführte Berechnung das gewünschte Ergebnis liefert. Solche Programme enthalten sowohl eine Schleife, die einen zu wiederholenden Abschnitt definiert, als auch einen bedingten Ausdruck, der prüft, ob die Bedingung zum Verlassen der Schleife erfüllt ist.
Eingaben können auch innerhalb einer Schleife vom Nutzenden abgefragt werden. Die in Schleifen häufig verwendeten Variablen (wie Scanner-Objekte) werden vor der Schleife definiert, während Variablen, die spezifisch für die Schleife sind (wie der vom Nutzenden eingegebene Wert), innerhalb der Schleife definiert werden.
Im folgenden Beispiel fragt das Programm den Nutzenden, ob die Schleife verlassen werden soll. Wenn der Nutzende den String "y" eingibt, wird die Ausführung des Programms zum Befehl nach dem Schleifenblock fortgesetzt, wonach die Programmausführung endet.
Scanner scanner = new Scanner(System.in);
while (true) {
System.out.println("Exit? (y exits)");
String input = scanner.nextLine();
if (input.equals("y")) {
break;
}
System.out.println("Ok! Let's carry on!");
}
System.out.println("Ready!");Das Programm im Beispiel funktioniert wie folgt. Die Eingaben des Nutzenden sind rot markiert.
Exit? (y exits) no Ok! Let's carry on! Exit? (y exits) non Ok! Let's carry on! Exit? (y exits) y Ready!
Im vorherigen Beispiel las das Programm Eingaben vom Typ String vom Nutzenden. Das Programm kann auch mit anderen Variablentypen implementiert werden. Das folgende Programm fragt den Nutzenden nach Zahlen, bis der Nutzende eine Null eingibt.
Scanner scanner = new Scanner(System.in);
while (true) {
System.out.println("Input a number, 0 to quit");
int command = Integer.valueOf(scanner.nextLine());
if (command == 0) {
break;
}
System.out.println("You input " + command);
}
System.out.println("Done, thank you!");Die Ausgabe des Programms kann wie folgt aussehen:
Input a number, 0 to quit 5 You input 5 Input a number, 0 to quit -2 You input -2 Input a number, 0 to quit 0 Done, thank you!
Zurück zum Anfang der Schleife
Wenn die Ausführung das Ende der Schleife erreicht, beginnt die Ausführung erneut von Anfang an. Das bedeutet, dass alle Befehle in der Schleife ausgeführt wurden. Sie können auch von anderen Stellen als dem Ende der Schleife zum Anfang zurückkehren, indem Sie den Befehl continue verwenden. Wenn der Computer den Befehl continue ausführt, wird die Programmausführung an den Anfang der Schleife verschoben.
Das folgende Beispiel zeigt die Verwendung des continue-Befehls. Das Programm fordert den Nutzenden auf, positive Zahlen einzugeben. Wenn der Nutzende eine negative Zahl oder eine Null eingibt, druckt das Programm die Meldung "Unfit number, try again", woraufhin die Ausführung zum
Anfang der Schleife zurückkehrt. Im vorherigen Beispiel las das Programm Eingaben vom Typ String vom Nutzenden. Ähnliche Programme mit anderen Eingabetypen sind ebenfalls möglich. Im folgenden Beispiel wird der Nutzende aufgefordert, Zahlen einzugeben, bis eine Null eingegeben wird.
Scanner scanner = new Scanner(System.in);
while (true) {
System.out.println("Insert positive integers");
int number = Integer.valueOf(scanner.nextLine());
if (number <= 0) {
System.out.println("Unfit number! Try again.");
continue;
}
System.out.println("Your input was " + number);
}Die Schleide im obigen Beispiel würde "unendlich" oft wiederholt, da der break-Befehl zum Verlassen der Schleife nicht verwendet wird. Um die Schleife zu beenden, muss der break-Befehl hinzugefügt werden.
Im folgenden Beispiel wird das Programm so modifiziert, dass der Nutzende aufgefordert wird, positive Zahlen einzugeben. Wenn der Nutzende eine negative Zahl eingibt, informiert das Programm darüber, dass die Zahl unzulässig war, und kehrt zum Anfang der Schleife zurück. Wenn die Zahl null ist, verlässt das Programm die Schleife.
Scanner scanner = new Scanner(System.in);
while (true) {
System.out.println("Input positive numbers.");
int number = Integer.valueOf(scanner.nextLine());
if (number == 0) {
break;
}
if (number < 0) {
System.out.println("Unfit number! Try again.");
continue;
}
System.out.println("Your input was " + number);
}Loading...
Im vorherigen Beispiel haben Sie ein Programm erstellt, das den Nutzenden nach Zahlen fragt. Wenn der Nutzende eine negative Zahl eingegeben hat, informiert das Programm darüber, dass die Zahl unzulässig war, und wenn der Nutzende eine null eingegeben hat, beendet das Programm die Schleife. Eine mögliche Lösung für die Aufgabe ist die folgende.
Scanner scanner = new Scanner(System.in);
while (true) {
System.out.println("Input a number");
int number = Integer.valueOf(scanner.nextLine());
if (number == 0) {
break;
}
if (number < 0) {
System.out.println("Unfit number");
continue;
}
System.out.println(number * number);
}Das Programm könnte auch durch eine andere Form des if-Statements erstellt werden. Im folgenden Beispiel wurden die Bedingungen kombiniert, um separate if-Statements zu ersetzen.
Scanner scanner = new Scanner(System.in);
while (true) {
System.out.println("Input a number");
int number = Integer.valueOf(scanner.nextLine());
if (number == 0) {
break;
} else if (number < 0) {
System.out.println("Unfit number");
continue;
}
System.out.println(number * number);
}Welches der vorherigen Beispiele war klarer?
Betrachten wir die Klarheit der vorherigen Programme anhand eines Beispiels. Unten fragt das Programm den Nutzenden nach einer Zahl. Wenn die Zahl negativ ist, wird der Nutzende darüber informiert, dass die Zahl unzulässig ist, und die Ausführung des Programms wird an den Anfang der Schleife zurückgesetzt. Wenn die Zahl null ist, beendet das Programm die Schleife. In anderen Fällen druckt das Programm das Quadrat der Zahl, d.h. die Zahl mal sich selbst.
Scanner scanner = new Scanner(System.in);
while (true) {
System.out.println("Input a number ");
int number = Integer.valueOf(scanner.nextLine());
if (number < 0) {
System.out.println("Unfit number");
continue;
}
if (number == 0) {
break;
}
System.out.println(number * number);
}Dieses Programm kann auch durch Kombinieren der if-Statements erstellt werden. In diesem Fall sieht die Implementierung wie folgt aus.
Scanner scanner = new Scanner(System.in);
while (true) {
System.out.println("Input a number ");
int number = Integer.valueOf(scanner.nextLine());
if (number < 0) {
System.out.println("Unfit number");
} else if (number == 0) {
break;
} else {
System.out.println(number * number);
}
}Betrachten wir die vorherigen Programme mit Kommentaren. Vor jedem Befehl steht ein Kommentar, der versucht zu erklären, was im Programm passiert. Unten ist ein Programm, das mit separaten if-Statements geschrieben wurde.
// Die Aufgabe besteht darin, eine Eingabe vom Nutzenden zu lesen
Scanner scanner = new Scanner(System.in);
// Die Aufgabe besteht darin, den Block so lange zu wiederholen, bis der Block verlassen wird
while (true) {
// Die Aufgabe besteht darin, den Nutzenden um eine Eingabe zu bitten
System.out.println("Input a number ");
// Die Aufgabe besteht darin, eine Zahl vom Nutzenden zu lesen
int number = Integer.valueOf(scanner.nextLine());
// Die Aufgabe besteht darin, unzulässige Zahlen zu verhindern
if (number < 0) {
System.out.println("Unfit number");
continue;
}
// Die Aufgabe besteht darin, zu überprüfen, ob die Schleife verlassen werden soll
if (number == 0) {
break;
}
// Die Aufgabe besteht darin, das Quadrat der Zahl auszudrucken
System.out.println(number * number);
}Beachten Sie, dass jede if-Anweisung eine einzelne, klare Aufgabe hat.
Wenn wir ein Programm kommentieren, das kombinierte if-Statements enthält, nehmen die Kommentare die folgende Form an.
// Die Aufgabe besteht darin, eine Eingabe vom Nutzenden zu lesen
Scanner scanner = new Scanner(System.in);
// Die Aufgabe besteht darin, den Block so lange zu wiederholen, bis der Block verlassen wird
while (true) {
// Die Aufgabe besteht darin, den Nutzenden um eine Eingabe zu bitten
System.out.println("Input a number ");
// Die Aufgabe besteht darin, eine Zahl vom Nutzenden zu lesen
int number = Integer.valueOf(scanner.nextLine());
// Was ist der Zweck des if-else if-else-Blocks?
// Die Aufgabe besteht in der Verarbeitung der Zahl?
if (number < 0) {
System.out.println("Unfit number");
} else if (number == 0) {
break;
} else {
System.out.println(number * number);
}
}Wir stellen fest, dass es schwierig ist, eine einzelne, klare Aufgabe für den if-else if-else-Block zu definieren. Während des Designs und Implementierung eines Programms ist es wünschenswert, eine Situation anzustreben, in der jeder Teil des Programms eine einzige, klare Aufgabe hat. Dieses Thema wird sich im Laufe des Kurses wiederholen.
Berechnung mit Schleifen
Schleifen werden verwendet, um viele verschiedene Dinge zu berechnen. Zum Beispiel verwenden Programme, die eine unbestimmte Anzahl von Nutzereingaben verarbeiten, Schleifen. Solche Programme drucken typischerweise nach dem Ende der Schleife einige Statistiken über die gelesenen Zahlen oder andere Eingaben aus.
Damit das Programm nach der Schleife Informationen aus der Schleifenausführung drucken kann, müssen die Informationen während der Schleife gespeichert und geändert werden.
Wenn die Variable, die zum Speichern der Daten verwendet wird, innerhalb der Schleife eingeführt wird, ist die Variable nur innerhalb dieser Schleife und nirgendwo anders verfügbar.
Erstellen wir ein Programm, das die Anzahl der eingegebenen Einsen zählt und ausgibt. Erstellen wir zuerst eine nicht funktionierende Version und untersuchen die Aktion der Blöcke.
Scanner scanner = new Scanner(System.in);
// Die Aufgabe besteht darin, eine Eingabe vom Nutzenden zu lesen
while (true) {
// Die Aufgabe besteht darin, die Anzahl der Einsen zu zählen
int ones = 0;
System.out.println("Input a number (0 exits): ");
// Die Aufgabe besteht darin, eine vom Nutzenden eingegebene Zahl zu lesen
int number = Integer.valueOf(scanner.nextLine());
// Die Aufgabe besteht darin, die Schleife zu verlassen, wenn der Nutzende null eingegeben hat
if (number == 0) {
break;
}
// Die Aufgabe besteht darin, die Anzahl der Einsen zu erhöhen
// wenn der Nutzende eine Eins eingibt
if (number == 1) {
ones = ones + 1;
}
}
// Die Aufgabe besteht darin, die Gesamtzahl der Einsen auszugeben
// Dies funktioniert nicht, da die Variable ones innerhalb der Schleife eingeführt wurde
System.out.println("The total of ones: " + ones);Das vorherige Programm funktioniert nicht, weil die Variable ones innerhalb der Schleife eingeführt wird und versucht wird, sie nach der Schleife am Ende des Programms zu verwenden. Die Variable existiert nur innerhalb der Schleife. Wenn die Druckanweisung System.out.println("The total of ones: " + ones); innerhalb der Schleife wäre, würde das Programm funktionieren, aber nicht wie gewünscht. Sehen wir uns das als nächstes an.
Scanner scanner = new Scanner(System.in);
// Die Aufgabe besteht darin, eine Eingabe vom Nutzenden zu lesen
while (true) {
// Die Aufgabe besteht darin, die Anzahl der Einsen zu zählen
int ones = 0;
System.out.println("Insert a number (0 exits): ");
// Die Aufgabe besteht darin, eine vom Nutzenden eingegebene Zahl zu lesen
int number = Integer.valueOf(scanner.nextLine());
// Die Aufgabe besteht darin, die Schleife zu verlassen, wenn der Nutzende null eingegeben hat
if (number == 0) {
break;
}
// Die Aufgabe besteht darin, die Anzahl der Einsen zu erhöhen
// wenn der Nutzende eine Eins eingibt
if (number == 1) {
ones = ones + 1;
}
// Die Aufgabe besteht darin, die Gesamtzahl der Einsen auszugeben
System.out.println("The total of ones: " + ones);
}Das obige Beispiel funktioniert, aber nicht so, wie wir es uns erhofft haben. Nachfolgend das Beispiel einer Programmausgabe.
Insert a number (0 exits) 5 The total of ones: 0 Insert a number (0 exits) 1 The total of ones: 1 Insert a number (0 exits) 1 The total of ones: 1 Insert a number (0 exits) 2 The total of ones: 0 Insert a number (0 exits) 0
Wenn Sie eine Variable nach einer Schleife verwenden möchten, muss sie vor der Schleife eingeführt werden.
Im folgenden Beispiel berechnet das Programm die Gesamtzahl der eingegebenen Einsen. Die Eingaben werden gelesen, bis der Nutzende eine null eingibt, danach druckt das Programm die Gesamtzahl der eingegebenen Einsen aus. Das Programm verwendet die Variable ones, um die Anzahl der Einsen zu verfolgen.
Scanner scanner = new Scanner(System.in);
// Die Aufgabe besteht darin, die Anzahl der Einsen zu verfolgen
int ones = 0;
// Die Aufgabe besteht darin, eine Eingabe vom Nutzenden zu lesen
while (true) {
System.out.println("Give a number (end with 0): ");
// Die Aufgabe besteht darin, eine vom Nutzenden eingegebene Zahl zu lesen
int number = Integer.valueOf(scanner.nextLine());
// Die Aufgabe besteht darin, die Schleife zu verlassen, wenn der Nutzende null eingegeben hat
if (number == 0) {
break;
}
// Die Aufgabe besteht darin, die Anzahl der Einsen zu erhöhen
// wenn der Nutzende eine Eins eingibt
if (number == 1) {
ones = ones + 1;
}
}
// Die Aufgabe besteht darin, die Gesamtzahl der Einsen auszugeben
System.out.println("The total of ones: " + ones);Nachfolgend ein Beispiel für die Programmausgabe.
Give a number (end with 0): 1 Give a number (end with 0): 2 Give a number (end with 0): 1 Give a number (end with 0): -1 Give a number (end with 0): 0 Total of ones: 2
Die Programme, die in den vorherigen Übungen erstellt wurden, haben Eingaben vom Nutzenden gelesen und die Anzahl bestimmter Typen von Zahlen verfolgt. In der nächsten Übung unterscheidet sich die geforderte Summe der Zahlen nicht wesentlich von den vorherigen Aufgaben – dieses Mal wird jedoch nicht die Anzahl der eingegebenen Werte gezählt, sondern die vom Nutzenden eingegebene Zahl zur Summe hinzugefügt.
Manchmal müssen mehrere Variablen verwendet werden. Das folgende Beispiel zeigt ein Programm, das Zahlen vom Nutzenden liest, bis dieser eine null eingibt. Dann druckt das Programm die Anzahl der eingegebenen positiven und negativen Zahlen aus und den Prozentsatz der positiven Zahlen von allen eingegebenen Zahlen.
Scanner reader = new Scanner(System.in);
// Zum Speichern der Anzahl der Zahlen
int numberOfPositives = 0;
int numberOfNegatives = 0;
// Für die wiederholte Abfrage von Zahlen
while (true) {
System.out.println("Give a number (0 to stop): ");
// Zum Lesen der Nutzereingabe
int numberFromUser = Integer.valueOf(reader.nextLine());
// Zum Beenden der Schleife, wenn der Nutzende eine null eingibt
if (numberFromUser == 0) {
break;
}
// Zum Erhöhen der numberOfPositives um eins
// wenn der Nutzende eine positive Zahl eingibt
if (numberFromUser > 0) {
numberOfPositives = numberOfPositives + 1;
}
// Zum Erhöhen der numberOfNegatives um eins
// wenn der Nutzende eine negative Zahl eingibt
if (numberFromUser < 0) {
numberOfNegatives = numberOfNegatives + 1;
}
// Man könnte auch verwenden..
// if (numberFromUser > 0) {
// numberOfPositives = numberOfPositives + 1;
// } else {
// numberOfNegatives = numberOfNegatives + 1;
// }
}
// Zum Drucken der Anzahl der positiven Zahlen
System.out.println("Positive numbers: " + numberOfPositives);
// Zum Drucken der Anzahl der negativen Zahlen
System.out.println("Negative numbers: " + numberOfNegatives);
// Zum Drucken des Prozentsatzes der positiven Zahlen von allen Zahlen
if (numberOfPositives + numberOfNegatives > 0) {
// Druckt nur, wenn der Nutzende Zahlen eingegeben hat
// um eine Division durch null zu vermeiden
double percentageOfPositives = 100.0 * numberOfPositives / (numberOfPositives + numberOfNegatives);
System.out.println("Percentage of positive numbers: " + percentageOfPositives + "%");
}