Mehr Schleifen

Die "while-true"-Schleife, die wir bisher verwendet haben, ist sehr praktisch, wenn das Programm eine Funktionalität wiederholen muss, bis der Benutzer eine bestimmte Eingabe macht.

Als Nächstes werden wir einige andere Möglichkeiten kennenlernen, Schleifen zu implementieren.

While-Schleife mit einer Bedingung

Bisher haben wir eine Schleife verwendet, bei der in den Klammern der boolesche Wert true steht, was bedeutet, dass die Schleife für immer weiterläuft (oder bis die Schleife mit dem Befehl break beendet wird).

Tatsächlich können die Klammern einer Schleife einen bedingten Ausdruck oder eine Bedingung enthalten, genau wie die Klammern einer if-Anweisung. Der Wert true kann durch einen Ausdruck ersetzt werden, der während der Programmausführung ausgewertet wird. Der Ausdruck wird auf die gleiche Weise definiert wie die Bedingung einer Bedingungsanweisung.

Der folgende Code gibt die Zahlen 1, 2,..., 5 aus. Wenn der Wert der Variablen number größer als 5 ist, wird die while-Bedingung zu false und die Ausführung der Schleife wird endgültig beendet.

int number = 1;

while (number < 6) {
    System.out.println(number);
    number++;
}

Der obige Code kann wie folgt gelesen werden: "Solange der Wert der Variablen number kleiner als 6 ist, geben Sie den Wert der Variablen number aus und erhöhen Sie den Wert der Variablen number um eins".

Oben wird der Wert der Variablen number jedes Mal um eins erhöht, wenn der Schleifenblock ausgeführt wird.

For-Schleife

Oben haben wir gelernt, wie eine while-Schleife mit einer Bedingung verwendet werden kann, um Zahlen in einem bestimmten Intervall durchzugehen.

Die Struktur einer solchen Schleife ist die folgende.

int i = 0;
while (i < 10) {
    System.out.println(i);
    i++;
}

Die obige Schleife kann in drei Teile zerlegt werden. Zuerst führen wir die Variable i ein, die verwendet wird, um die Anzahl der bisherigen Ausführungen der Schleife zu zählen, und setzen ihren Wert auf 0: int i = 0;. Danach erfolgt die Definition der Schleife – die Bedingung der Schleife ist i < 10, also wird die Schleife so lange ausgeführt, wie der Wert der Variablen i kleiner als 10 ist. Der Schleifenblock enthält die auszuführende Funktionalität System.out.println(i);, gefolgt von der Erhöhung des Wertes der Variablen i++. Der Befehl i++ ist eine Kurzform für i = i + 1.

Das Gleiche kann mit einer for-Schleife wie folgt erreicht werden.

for (int i = 0; i < 10; i++) {
    System.out.println(i);
}

Eine for-Schleife enthält vier Teile: (1) die Einführung der Variablen zur Zählung der Ausführungen; (2) die Bedingung der Schleife; (3) die Erhöhung (oder Verringerung oder Änderung) des Wertes der Zählvariablen; und (4) die auszuführende Funktionalität.

for (*Variableneinfuehrung*; *Bedingung*; *Erhoehung_des_Zaehlers*) {
    // Auszuführende Funktionalität
}

Die Schleifenausführung wird unten schrittweise gezeigt.

Das obige Beispiel gibt die Zahlen von null bis vier aus. Das Intervall kann auch mit Variablen definiert werden – im folgenden Beispiel werden die Variablen start und end verwendet, um das Intervall der durchlaufenen Zahlen zu definieren.

int start = 3;
int end = 7;
for (int i = start; i < end; i++) {
    System.out.println(i);
}

Wir werden in den folgenden Übungen weiter Schleifen üben. Sie können entweder eine while-Schleife mit einer Bedingung oder eine for-Schleife verwenden.

Zum Beenden einer Schleifenausführung

Eine Schleife stoppt die Ausführung nicht sofort, wenn ihre Bedingung wahr wird. Die Bedingung einer Schleife wird am Anfang einer Schleife überprüft, also entweder (1) wenn die Schleife zum ersten Mal startet oder (2) wenn die Ausführung einer vorherigen Iteration des Schleifenblocks gerade abgeschlossen wurde.

Schauen wir uns die folgende Schleife an.

int number = 1;

while (number != 2) {
    System.out.println(number);
    number = 2;
    System.out.println(number);
    number = 1;
}

Sie gibt Folgendes aus:

Obwohl number zu einem bestimmten Zeitpunkt 2 ist, läuft die Schleife für immer weiter.

Die Bedingung einer Schleife wird überprüft, wenn die Ausführung einer Schleife beginnt und wenn die Ausführung des Schleifenblocks die schließende geschweifte Klammer erreicht hat. Wenn die Bedingung wahr ist, wird die Ausführung vom Anfang des Schleifenblocks fortgesetzt. Wenn die Bedingung falsch ist, wird die Ausführung mit der ersten Anweisung nach der Schleife fortgesetzt.

Dies gilt auch für for-Schleifen. Im folgenden Beispiel wäre es falsch anzunehmen, dass die Schleifenausführung endet, wenn i gleich 100 ist. Das ist jedoch nicht der Fall.

for (int i = 0; i != 100; i++) {
    System.out.println(i);
    i = 100;
    System.out.println(i);
    i = 0;
}

Die obige Schleife hört nie auf zu laufen.

Wiederholungen

Ein häufiges Unterproblem besteht darin, "etwas eine bestimmte Anzahl von Malen zu tun". Was all diesen Programmen gemeinsam ist, ist die Wiederholung. Eine Funktionalität wird wiederholt ausgeführt, und eine Zählvariable wird verwendet, um die Anzahl der Wiederholungen zu verfolgen.

Das folgende Programm berechnet das Produkt 4*3 auf etwas umständliche Weise, d. h. als Summe 3 + 3 + 3 + 3:

int result = 0;

int i = 0;
while (true) {
    result += 3; // Kurzform für result = result + 3
    i++;  // Kurzform für i = i + 1

    if (i == 4) {
        break;
    }
}

System.out.println(result);

Dieselbe Funktionalität kann auch mit dem folgenden Code erreicht werden.

int result = 0;

int i = 0;
while (i < 4) {
    result += 3; // Kurzform für result = result + 3
    i++;  // Kurzform für i = i + 1

}

System.out.println(result);

Oder durch die Verwendung einer for-Schleife wie im Folgenden:

int result = 0;

for (int i = 0; i < 4; i++) {
    result += 3;
}

System.out.println(result);

Die Programmausführung unter Verwendung einer while-Schleife wird unten visualisiert.

Über die Struktur von Programmen mit Schleifen

In den vorherigen Beispielen haben wir uns auf Fälle konzentriert, in denen die Schleife eine vorbestimmte Anzahl von Malen ausgeführt wird. Die Anzahl der Wiederholungen kann auf Benutzereingaben basieren – in diesen Fällen ist die for-Schleife sehr praktisch.

In Programmen, in denen der Schleifenblock ausgeführt werden muss, bis der Benutzer eine bestimmte Eingabe macht, ist die for-Schleife nicht so gut geeignet. In diesen Fällen funktioniert die while-true-Schleife, die wir zuvor geübt haben, gut.

Schauen wir uns ein etwas komplexeres Programm an, das Ganzzahlen vom Benutzer liest. Das Programm behandelt negative Zahlen als ungültig, und Null stoppt die Schleife. Wenn der Benutzer Null eingibt, gibt das Programm die Summe der gültigen Zahlen, die Anzahl der gültigen Zahlen und die Anzahl der ungültigen Zahlen aus.

Eine mögliche Lösung wird unten beschrieben. Der Stil des Beispiels ist jedoch nicht ideal.

Scanner reader = new Scanner(System.in);

System.out.print("Geben Sie Zahlen ein, negative Zahlen sind ungültig: ");
int sum = 0;
int validNumbers = 0;
int invalidNumbers = 0;

while (true) {
    int input = Integer.valueOf(reader.nextLine());

    if (input == 0) {
        System.out.println("Summe der gültigen Zahlen: " + sum);
        System.out.println("Gültige Zahlen: " + validNumbers);
        System.out.println("Ungültige Zahlen: " + invalidNumbers);
        break;
    }

    if (input < 0) {
        invalidNumbers++;
        continue;
    }

    sum += input;
    validNumbers++;
}

Im obigen Code wurde die Berechnung, die nach dem Ende der Schleife ausgeführt wird, in die Schleife implementiert. Dieser Ansatz wird nicht empfohlen, da er leicht zu einer sehr komplexen Programmstruktur führen kann. Wenn beim Beenden der Schleife etwas anderes gemacht werden muss – zum Beispiel das Einlesen weiterer Eingaben –, könnte es auch leicht innerhalb der Schleife platziert werden. Wenn immer mehr Funktionalität benötigt wird, wird das Programm zunehmend schwerer zu lesen.

Halten wir uns an die folgende Schleifenstruktur:

Scanner reader = new Scanner(System.in);

// Erstellen Sie die für die Schleife benötigten Variablen

while (true) {
    // Eingabe lesen

    // Schleife beenden – break

    // Überprüfen auf ungültige Eingaben – continue

    // Gültige Eingaben verarbeiten
}

// Funktionalität, die nach dem Ende der Schleife ausgeführt wird

Mit anderen Worten, die Programmstruktur ist sauberer, wenn die nach dem Ende der Schleife zu erledigenden Dinge außerhalb der Schleife platziert werden.

Scanner reader = new Scanner(System.in);

System.out.print("Geben Sie Zahlen ein, negative Zahlen sind ungültig: ");
int sum = 0;
int validNumbers = 0;
int invalidNumbers = 0;

while (true) {
    int input = Integer.valueOf(reader.nextLine());

    if (input == 0) {
        break;
    }

    if (input < 0) {
        invalidNumbers++;
        continue;
    }

    sum += input;
    validNumbers++;
}

System.out.println("Summe der gültigen Zahlen: " + sum);
System.out.println("Gültige Zahlen: " + validNumbers);
System.out.println("Ungültige Zahlen: " + invalidNumbers);