while Schleife Java

Java while Schleife einfach erklärt

In Java unterscheidet man drei Schleifen: die for Schleife, while Schleife und die do while Schleife. Wir beschäftigen uns hier mit der while und der do while Schleife. Der Aufbau einer while Schleife sieht so aus:

direkt ins Video springen

Die while Schleife wird nur unter einer bestimmten Bedingung ausgeführt. Diese Bedingung schreibst du in die runde Klammern. Wenn diese erfüllt ist, wird der Code, der sich innerhalb der geschweiften Klammern befindet, ausgeführt. Daraufhin wird überprüft, ob die Bedingung noch erfüllt ist. Sollte dass der Fall sein, springt unser Programm zum Anfang der Schleife zurück. Das passiert so lange, bis die Bedingung nicht mehr erfüllt ist. Danach läuft das Programm weiter durch den restlichen Code. Bei der do while Schleife sieht das etwas anders aus, aber darauf kommen wir später nochmal zurück.

Beispiel: while Schleife Java

Nun schauen wir uns gemeinsam an einem konkreten Beispiel an, wie die while Schleife in Java genau funktioniert. Hierfür betrachten wir einen Klickzähler, der eine Zahl immer um eins erhöht. Dabei soll abgebrochen werden, wenn der Klickzähler den Wert 10 erreicht.

direkt ins Video springen

Schauen wir uns an, wie du so etwas in Java umsetzen kannst. Hierfür deklarierst du zunächst außerhalb der while Schleife eine Variable counter und weist ihr den Wert null zu

int counter = 0;

Die Variable counter wird im folgenden unsere Laufvariable sein, welche bei null starten soll. Als Nächtes kommt das Schlüsselwort while. Damit weiß der Computer, dass jetzt eine while Schleife folgt. Am besten programmierst du gleich die Struktur einer while Schleife

int counter = 0;
while(Bedingung){
    //Anweisungen
}

Nun benötigst du noch eine Bedingung in den runden Klammern, in welcher du angibst, wann die while Schleife abbrechen soll. In unserem Fall soll die while Schleife solange ausgeführt werden, bis die Laufvariable gleich dem Wert 10 entspricht. Hat die Laufvariable counter also den Wert 11, dann bricht sie ab. Dies erreichst du durch die Bedingung counter <= 10. Damit hat deine while Schleife nun folgende Gestalt

int counter = 0;
while( counter <= 10 ){
    //Anweisungen
}

Jetzt fehlen dir nur noch die Anweisungen, was die while Schleife machen soll. Angenommen du möchtest dir den Wert der Laufvariablen counter auf der Konsole ausgegeben lassen, dann erreichst du das mit dem Befehl System.out.println. Danach musst du dann nur noch deine Laufvariable um eins erhöhen mit counter++

int counter = 0;
while( counter <= 10){
    System.out.println("Zahler: " + counter);
    counter++;
}

Schon bist du mit deiner ersten while Schleife fertig! Jetzt läuft die Schleife solange, bis counter = 11 ist, denn dann ist die Bedingung der while Schleife nicht mehr erfüllt und sie bricht ab. Es gibt in Java auch eine Schleife, welche mit der while Schleife starke Ähnlichkeit hat, nämlich die do while Schleife. Diese schauen wir uns nun genauer an.

do while Java

Im Folgenden lernst du die do while Schleife in Java kennen. Der große Unterschied zwischen der while und der do while Schleife liegt darin, dass die while Schleife die Bedingung im Vornherein überprüft und die do while Schleife erst zum Schluss

do{
    //Anweisung
}
while(Bedingung);

Ihr Prinzip ist recht ähnlich zur while Schleife. Diesmal steht der Code aber nicht nach, sondern vor der Schleife. Das führt dazu, dass erst der Code ausgeführt und dann die Bedingung geprüft wird. Ganz wichtig ist dabei, dass du nach der Bedingung ein Semikolon setzt!

direkt ins Video springen

While Schleifen verschachteln

Zusätzlich kannst du while Schleifen natürlich beliebig verschachteln. Das heißt, dass innerhalb einer while Schleife eine weitere durchgeführt wird. Also vereinfacht gesagt: Zunächst wird von der äußeren Schleife die Bedingung geprüft. Wenn diese zutrifft, wird die der inneren Schleife überprüft. Diese läuft dann so lange weiter, bis die Bedingung nicht mehr erfüllt ist. Erst danach geht das Programm zurück in die äußere Schleife und führt, sofern vorhanden, den Code unterhalb der inneren Schleife aus.

Beispiel

Schauen wir uns dazu ein Beispiel an:

direkt ins Video springen

Hier haben wir außerhalb der Schleife die integer Variable counter mit dem Wert 0 initialisiert und in der äußeren Schleife dann die integer Variable subCounter mit dem Wert 0. Hierbei ist es wichtig, dass die Variable subCounter in der äußeren Schleife initialisiert wird! Es gibt dabei zwei Wege. Entweder, wir deklarieren subCounter außerhalb der Schleife und weisen ihm keinen Wert zu, oder wir deklarieren und initialisieren sie in der äußeren Schleife. Das ist essentiell, da die Variable subCounter sonst nach dem vollständigen Durchlauf der inneren Schleife immer den Wert 4 hat und so die innere Schleife nicht mehr aufgerufen wird. Wenn du aber bei jedem Aufruf der äußeren Schleife den Wert der Variable subCounter auf 0 zurücksetzt, kann die innere Schleife wieder ausgeführt werden. Das erreichst du gerade durch int subCounter = 0;.

Der Ablauf der zwei verschachtelten Schleifen ist dann wie folgt. Zuerst wird überprüft, ob counter einen Wert kleiner gleich 10 hat. Wenn das zutrifft, wird er auf der Konsole ausgegeben und um 1 erhöht. Außerdem weisen wir subCounter den Wert 0 zu. Danach wird die zweite Schleife aufgerufen und überprüft, ob subCounter kleiner gleich 3 ist. Dann wird auch hier der Wert ausgegeben und anschließend erhöht. Wenn subCounter den Wert 4 erreicht hat, ist die Bedingung kleiner gleich 3 nicht mehr gegeben und das Programm springt zurück in die äußere Schleife. Die Anweisungen der äußeren Schleife werden dann wieder von oben nach unten abgearbeitet. Da subCounter jetzt den Wert 0 hat, kann die innere Schleife wieder problemlos ausgeführt werden.

Mehrfach Verschachtelungen

Du kannst solche mehrdimensionalen oder auch verschachtelten Schleifen auch noch weiter verschachteln. Sei es, dass in deiner Schleife noch eine Schleife ist, oder deine äußere Schleife zwei innere Schleifen hat. Allerdings benutzt man für solche Verschachtelungen eher die for Schleife . Diese ist anders aufgebaut und erspart etwas mehr Arbeit als die while Schleife.

Endlosschleifen

Ganz wichtig ist auch, dass du KEINE Endlosschleifen einbaust! Eine Endlosschleife erzeugst du, indem die Bedingung immer erfüllt ist und so die Schleife nie abbricht. Das kann dazu führen, dass dein Programm abstürzt. In unserem Fall könnte dies eintreten, wenn du vergisst, eine der Laufvariablen hochzuzählen und sie zu Beginn einen Wert erhalten, sodass die Schleifenbedingung immer erfüllt ist.