Im heutigen Beitrag wirst du die Java While Schleife kennenlernen. Wir sehen uns dabei im ersten Schritt an, was eine Schleife überhaupt ist und welche anderen Schleifenarten es neben dieser noch gibt. Diese wirst du dann später in einem anderen Artikel kennenlernen. Anschließend werden wir im Detail auf die While Schleife eingehen, sodass du am Ende in der Lage sein wirst, sie selbst einzusetzen.
Sie sehen gerade einen Platzhalterinhalt von Youtube. Um auf den eigentlichen Inhalt zuzugreifen, klicken Sie auf die Schaltfläche unten. Bitte beachten Sie, dass dabei Daten an Drittanbieter weitergegeben werden.
Mehr InformationenInhaltsverzeichnis
1. Was ist eine Schleife?
Schleifen ermöglichen das wiederholte Ausführen von Codeblöcken. Was ein Codeblock ist, hast du bereits gelernt: nämlich alles, was zwischen geschweiften Klammern steht.
Wie du bereits bei den if-Abfragen gesehen hast, setzt sich ein Codeblock immer aus einer geöffneten und einer geschlossenen geschweiften Klammer zusammen und enthält dazwischen Anweisungen. All diese Anweisungen stellen gebündelt den Codeblock dar.
Mithilfe von Schleifen können wir diese Codeblöcke nun wiederholt ausführen. Das heißt, das Programm arbeitet sie nicht nur einmal ab und steuert weiter zum nächsten Codeabschnitt, sondern führt die Codeblöcke stattdessen direkt mehrmals hintereinander aus. Somit müssen wir sie nicht selbst wiederholt untereinander schreiben.
Jetzt stellt sich natürlich die Frage:
Wie lange sollte man den Code denn wiederholt ausführen lassen?
Diese Frage ist schnell beantwortet:
Nämlich solange bis das gewünschte Ergebnis erreicht wird.
Was man genau darunter versteht, wirst du noch lernen, wenn wir in der Praxis angekommen sind.
Mit Schleifen kann man zudem Datenstrukturen befüllen. Das sind beispielsweise Arrays oder Listen. Diese werden wir erst in einem späteren Artikel kennenlernen, weshalb du dir an dieser Stelle noch keine Gedanken darüber machen musst.
2. Die verschiedenen Schleifenarten
Zu Beginn habe ich schon erwähnt, dass es mehrere Arten von Schleifen gibt. Die Schleife, die wir heute behandeln werden, ist die Java While Schleife.
Neben dieser gibt es noch die Do-While-Schleife, die du dann im nächsten Beitrag kennenlernen wirst. Auch die sogenannte for-Schleife sehen wir uns in einem gesonderten Blogartikel an.
Außerdem existiert noch eine foreach-Schleife, bei der es sich um eine besondere Form der for-Schleife handelt. Diese ermöglicht es, über Datenstrukturen zu iterieren. Was ich damit meine, wirst du in einem anderen Beitrag noch lernen.
3. Wie funktionieren in Java While Schleifen?
Die Java While Schleife ähnelt sehr der if-Abfrage, die wir bereits kennengelernt haben.
Denn man wiederholt den Codeblock der While Schleife so lange, wie eine Bedingung erfüllt ist.
Genau wie bei der if-Abfrage also. Bei dieser bildet man zudem eine Bedingung mithilfe eines booleschen Ausdrucks, was man genauso bei der While Schleife umsetzt.
Weil das alles noch sehr abstrakt klingt, springen wir jetzt direkt mal in die Praxis und sehen uns das Ganze anhand eines Beispiels an.
Zuerst deklarieren wir hierfür eine Variable und initialisieren sie mit dem Wert 1:
int number = 1;
Jetzt werden wir ein Programm schreiben, das die Zahlen 1 bis 5 nacheinander in der Konsole ausgibt. Wir können nun natürlich sagen, dass wir uns fünf Variablen deklarieren, jeder einen Wert zuweisen und anschließend diese mit einer println-Methode nacheinander ausgeben.
Oder wir schreiben fünf println-Methoden untereinander:
System.out.println(1);
System.out.println(2);
System.out.println(3);
System.out.println(4);
System.out.println(5);
Anschließend speichern wir das Ganze und führen es aus.
Wie wir sehen, werden 1, 2, 3, 4 und 5 auf der Konsole ausgegeben:
In diesem Beispiel können wir den Code noch auf diese Art handhaben. Allerdings ist er eher unpraktisch, weil er sich mehrfach wiederholt.
Wir haben fünfmal die gleiche Anweisung, obwohl das Einzige, das sich verändert, der Wert zwischen den Klammern ist.
Auf diese Art und Weise sieht der Code nicht wirklich sauber aus. Zudem stellt sich die Frage, wie man mit dieser Vorgehensweise die Zahlen von 1 bis 10.000 auf der Konsole ausgeben würde. 10.000 println-Methoden untereinander zu schreiben, macht wohl wenig Sinn.
Genau an dieser Stelle kommen die sogenannten Schleifen ins Spiel. Wir löschen unseren Code nun nochmal bis zur Variable number und beginnen dann damit, uns eine while-Schleife zu bauen.
4. Die Java While Schleife in der Praxis
Dafür schreiben wir zunächst das Schlüsselwort while und dahinter ein rundes Klammerpaar für die Bedingung. Danach folgt der Schleifenblock, welcher durch geschweifte Klammern eingegrenzt wird:
while() {
}
Ob du die erste geschweifte Klammer neben while oder unter das Schlüsselwort setzt, bleibt dir überlassen. Für den Computer hat das keine Bedeutung.
Zwischen den geschweiften Klammern definieren wir jetzt den Schleifenblock. Alle Anweisungen, die wir gleich darin programmieren, werden so lange ausgeführt, wie die Bedingung oben zwischen dem runden Klammerpaar wahr ist.
Diese Bedingung muss ein boolescher Ausdruck sein, wodurch auch hier die Vergleichsoperatoren wieder zum Einsatz kommen.
Wir möchten nun die Zahlen 1 bis 5 auf der Konsole ausgeben lassen. Die Variable number, in der die Zahl 1 gespeichert ist, haben wir bereits definiert. Jetzt schreiben wir als Schleifenbedingung folgendes:
while(number <= 5) {
}
Diese Bedingung lässt die Schleife so lange ausführen, wie der Wert von number kleiner gleich fünf ist.
Bevor wir das Ergebnis auf der Konsole ausgeben, müssen wir den Wert von number in jedem Durchlauf erhöhen, damit dieser nicht immer gleich bleibt.
Das setzen wir folgendermaßen um:
while(number <= 5) {
System.out.println(number);
number = number + 1;
}
Damit erhöht das Programm den Wert von number in jedem Durchlauf um 1. Führen wir das Ganze nun aus, um zu sehen, was dabei passiert:
Wie wir sehen, erhalten wir durch diesen Code die gleiche Ausgabe wie zuvor. Die Zahlen 1 bis 5 werden auf der Konsole ausgegeben.
Gehen wir am besten noch einmal im Detail durch, was wir hier gemacht haben.
Zunächst initialisieren wir die Variable number mit dem Wert 1. Danach folgt die While Schleife.
while bedeutet übersetzt „während“ oder „solange“. Solange die Bedingung innerhalb der runden Klammern nach while erfüllt ist, führt das Programm den darauffolgenden Code immer wieder aus.
Die Bedingung ist also number <= 5 und number hat momentan den Wert 1. Deshalb wird dieser Codeblock schon einmal ausgeführt.
Was passiert dann? Das Programm gibt den aktuellen Wert von number aus, nämlich 1 und erhöht anschließend number um den Wert 1. Jetzt befindet sich in der Variable also der Wert 2.
Dann sehen wir zurück in die Bedingung. 2 ist kleiner als 5, was dazu führt, dass das Programm den Schleifenblock erneut ausführen wird. Das Ganze wiederholt sich so lange, bis die Bedingung nicht mehr erfüllt ist.
Wenn wir beispielsweise das =-Zeichen entfernen und stattdessen in der Bedingung number < 5 festlegen, gibt uns das Programm logischerweise nur 1 bis 4 auf der Konsole aus:
while(number < 5) {
System.out.println(number);
number = number + 1;
}
Ergänzen wir das =-Zeichen wieder, erhalten wir erneut 1 bis 5 in der Konsole.
Genauso könnten wir in die Bedingung die Zahl 6 schreiben und das Programm dann ausführen:
while(number <= 6) {
System.out.println(number);
number = number + 1;
}
Du kannst an dieser Stelle das Ganze selbst trainieren, indem du zum Beispiel die Bedingung der While Schleife beliebig veränderst.
Wenn wir die Variable beispielsweise auf die Zahl 3 setzen, startet die Schleife bei 3 und wir sehen, dass 3, 4, 5 und 6 ausgegeben werden:
int number = 3;
while(number <= 6) {
System.out.println(number);
number = number + 1;
}
So funktioniert also die While Schleife.
5. Die Gefahr bei der While Schleife
Was kann jetzt bei der While Schleife gefährlich werden?
Die Gefahr bei der Java While Schleife besteht darin, dass es schnell zu einer sogenannten Endlosschleife kommen kann.
Wie das passiert, siehst du, wenn du die Zeile, in der number um 1 erhöht wird, kurz auskommentierst:
int number = 1;
while(number <= 5) {
System.out.println(number);
//number = number + 1;
}
Wie du vielleicht bereits festgestellt hast, wird number jetzt immer den Wert 1 behalten, da dieser nirgendwo in der Schleife erhöht wird. Das heißt, das Programm führt die Schleife unendlich mal aus, weil die Bedingung immer wahr bleiben wird.
In der Konsole können wir das Dilemma beobachten:
Weil das unendlich lange so weiterlaufen wird, klicken wir auf den roten Stopp-Button, um das Programm zu terminieren und abzubrechen:
Du solltest also beim Verwenden der While Schleife immer darauf achten, dass der Schleifenzähler, an den die Bedingung gekoppelt ist, im Verlauf der Schleife erhöht wird und die Bedingung am Ende irgendwann nicht mehr erfüllt sein wird.
Wir entfernen also wieder die zwei /-Zeichen, damit die Codezeile wieder in unserem Programm ausgeführt wird:
while(number <= 5) {
System.out.println(number);
number = number + 1;
}
6. Die verkürzte Schreibweise beim Inkrementieren
Was ich dir an dieser Stelle noch kurz beibringen möchte, ist die Kurzschreibweise der folgenden Zeile:
number = number + 1;
Da wir darauf bisher noch nicht eingegangen sind, ist es jetzt an der Zeit, das nachzuholen.
Mit dieser Zeile erhöhen wir den aktuellen Wert 1 von number um 1 und weisen ihn dann wieder der Variable number zu.
Genau das können wir auch kürzer darstellen, weil es schon eine recht lange Anweisung für solch einen simplen Befehl ist. Das geht folgendermaßen:
number += 1;
Es handelt sich hierbei um einen sogenannten kombinierten Zuweisungsoperator. Diese Zeile stellt also die Kurzschreibweise von number = number + 1 dar.
Wir sparen uns dabei einmal „number“ und schreiben stattdessen das +-Zeichen vor den Zuweisungsoperator. Wenn wir diese Zeile jetzt ausführen, stellen wir fest, dass noch immer das gleiche Ergebnis herauskommt:
Damit hast du einen kleinen Trick gelernt, mit welchem du deine Anweisungen verkürzen kannst.
7. Die verkürzte Schreibweise beim Erhöhen um 1
Wenn wir den Wert einer Variable nur um 1 erhöhen möchten, können wir eine noch kürzere Schreibweise verwenden. Wichtig ist aber, dass diese wirklich nur beim Erhöhen um 1 eingesetzt werden kann. Die Schreibweise sieht folgendermaßen aus:
number++;
number++ hat die gleiche Wirkung wie number += 1. Das sehen wir, wenn wir die Zeile darüber auskommentieren und das Programm ausführen:
while(number <= 5) {
System.out.println(number);
//number += 1;
number++;
}
Wenn wir allerdings number += 2 in unserem Code gehabt hätten, dann würde die Schreibweise number++ nicht mehr funktionieren. Diese extrem schnelle Schreibweise gilt, wie bereits erwähnt, nur beim Erhöhen eines Wertes um 1.
Was die Java While Schleife von den anderen Schleifen unterscheidet, wird dir klar werden, sobald wir die anderen Schleifen behandelt haben.
8. Was bedeutet kopfgesteuert?
Die While Schleife ist eine sogenannte kopfgesteuerte Schleife. Das bedeutet, dass immer erst der Schleifenkopf ausgewertet wird:
while(number <= 5) { //Schleifenkopf
Danach steuert das Programm in den Schleifenkörper. Bei kopfgesteuerten Schleifen erfolgt also zunächst die Auswertung. Es wird im Fall unseres Beispiels die Bedingung number <= 5 geprüft und nur wenn diese erfüllt ist, führt das Programm den Codeblock darunter aus.
„Kopfgesteuert“ bezieht sich vor allem auf die erste Ausführung. Wenn wir nämlich von vornherein für number den Wert 6 festlegen, welcher nicht der Bedingung der While Schleife entspricht, stellen wir fest, dass die Schleife kein einziges Mal ausgeführt wird.
Das ist auch der Unterschied zur do-while-Schleife, die du im nächsten Beitrag kennenlernen wirst. Die do-while-Schleife ist nämlich fußgesteuert.
Das bedeutet wiederum: Auch wenn die Bedingung zu Beginn nicht erfüllt ist, führt das Programm die Schleife trotzdem mindestens einmal aus.
Wie das genau funktioniert, wirst du im Detail im nächsten Artikel erfahren.