Java Schnellstart – Schleifen

Stell dir vor, du kannst einen Roboter mit der Methode vor() steuern. Jedes Mal, wenn dieser Code ausgeführt wird, bewegt sich der Roboter um einen Meter nach vorne.

Jetzt soll der Roboter 10 Meter nach vorne läuft. Die Lösung? Wir können 10x die Methode vor() aufrufen. Doch was passiert, wenn der Roboter 100 Meter oder 1000 Meter nach vorne laufen soll?

Um die Methode vor() nicht 1000 Mal mit Copy/Paste in deinen Editor einzufügen, gibt es Schleifen. Mehr zu Schleifen erfährst du in dieser Lektion.

Was sind Schleifen?

Schleifen werden verwendet, um eine Reihe von Anweisungen wiederholt auszuführen, bis eine bestimmte Bedingung erfüllt ist. In Java gibt es drei Arten von Basisschleifen: for, while und do-while.

For-Schleife

Die For-Schleife wird typischerweise zum Zählen verwendet. Deshalb hört man häufig den Begriff Zählerschleife.

Zuerst Initialisiert man die sogenannte Laufvariable. Sie ist wichtig für die im Anschluss folgende Schleifenbedingung. Diese wird vor jedem (erneuten) Durchlauf überprüft.

Sollte diese Bedingung true sein, dann wird der Schleifenzyklus und somit der Schleifenrumpf ein weiteres Mal durchlaufen.
Sollte die Bedingung hingegen false sein, wird mit dem Programmcode unterhalb der Schleife weitergemacht.

Als letztes kommt der Fortschaltausdruck. Es handelt sich dabei um eine Anweisung, die nach jedem Durchlauf des Schleifenrumpfes ausgeführt wird.

Der allgemeine Aufbau einer for-Schleife sieht folgendermaßen aus:

for (Laufvariable; Schleifenbedingung; Fortschaltausdruck)
{
   // Schleifenrumpf
}

Bei unserem Roboter-Beispiel könnte das dann zum Beispiel so aussehen:

for(int i = 0; i &lt; 1000; i++)
{
	vor();
}
// ist die Bedingung false, "i" also nicht &lt; 1000, dann geht es hier, unter der Schleife, weiter

Erklärung des obigen Beispiels:

Dieser Code initialisiert eine Laufvariable vom Typ int und wir starten bei 0.
Danach kommt unsere Schleifenbedingung: i muss kleiner als 1000 sein.
Zum Schluss folgt der Fortschaltausdruck: i++, Die Variable "i" wird hier um +1 erhöht. Der Code erhöht also nach jedem Durchlauf von vor() die Laufvariable um +1.
Da wir die For-Schleife nur solange wie die Bedingung i < 1000 wahr ist ausführen wollen, laufen wir exakt um 1000 Meter nach vorne, da vor() 1000 Mal ausgeführt wird.

While-Schleife

Die While-Schleife führt ihren Schleifenblock aus, solange eine gegebene Bedingung wahr ist. Im Vergleich zur For-Schleife entfällt hier also der Fortschaltausdruck und die Laufvariable. Der allgemeine Aufbau sieht dann folgendermaßen aus:

while(Bedingung)
{
	// mache ...
}
// Ist die Bedingung false, geht es hier weiter...

Sobald die Bedingung false ist, so wird die Schleife beendet. Doch wofür ist das nun praktisch?

Stell dir vor, dein Roboter hat eine weitere Methode vorneFrei(). Diese Methode liefert dir einen Wert vom Typ Boolean (also "true" oder "false").

Wenn der Weg vorne frei ist, dann liefert die Methode den Wert true.
Befindet sich aber bspw. ein Hindernis vor dem Roboter, dann liefert die Methode den Wert false.

Mit der While-Schleife ist es nun möglich, den Roboter, solange vorlaufen zu lassen, bis ein Hindernis kommt:

while(vorneFrei())
{
      vor();
}

Do-While-Schleife

Bei der sogenannten Do-While-Schleife wird der Code im Anweisungsblock mindestens einmal ausgeführt, egal ob die Bedingung am Ende true (Wahr) oder false (Falsch) ist. Die Bedingung wird im Gegensatz zur While-Schleife am Ende geprüft. Der allgemeine Aufbau sieht folgendermaßen aus:

do {
	// Code
} while(Bedingung);

So sieht die Do-While Schleife für deinen Roboter aus:

do
{
	vor();
} while(vorneFrei());

Erklärung: Dein Roboter läuft mindestens einmal nach vorne, selbst wenn vor dem Roboter ein Hindernis ist und dadurch ein Unfall entstehen würde. Die Bedingung wird hier nämlich erst am Ende des ersten Durchlaufs geprüft. Läuft der Roboter jedoch einmal nach vorne und danach ist der Weg weiterhin frei, so wird der Code im Schleifenkörper wiederholt.

Code-Aufgabe - Jetzt bist du gefragt: Klimmzug-Automatisierung

Für einen Sporttest muss Max fit sein. Den 1000 Meter Lauf bekommt er ohne Probleme hin. Jedoch muss er 20 Klimmzüge hintereinander machen, die er ohne "Hilfe" nicht schafft.

Als cleverer Programmierer hilfst du ihm dabei eine Klimmzug-Maschine zu erstellen. Deine Aufgabe besteht darin, eine for-Schleife zu programmieren, die 20 Klimmzüge für Max macht und dann stoppt.

Tipp: Du kannst nach jedem Durchlauf eine kurze Nachricht in der Konsole ausgeben z.B. "Klimmzug geschafft" oder noch besser mit einer fortlaufenden Zahl des aktuellen Klimmzugs z.B. "1. Klimmzug geschafft"

[lp_spoiler title="Lösung anzeigen" class="da"]

class Main {
  public static void main(String[] args) {
    for(int i = 1; i &lt;= 20; i++) 
    { 
      System.out.println(i + ". Klimmzug geschafft!");
    }
  }
}

[/lp_spoiler]

Fazit

Schleifen ersparen dir viel Tipparbeit auf der Tastatur und machen deinen Code schlanker. Du solltest sie immer anwenden, wenn du etwas wiederholen möchtest.

Sollte dein Code eine bestimmte Anzahl an Wiederholungen durchführen, eignet sich die for-Schleife. Bei einer einfachen Bedingung solltest du dagegen die while-Schleife verwenden. Möchtest du Code innerhalb deiner Schleife mindestens einmal ausführen und dann mehrmals, je nachdem, ob eine bestimmte Bedingung wahr ist, so kannst du die do-while-Schleife benutzen.