Skip to main content

So funktioniert die While Schleife in deinem Java Programm


java-programmierung-while-schleife

Manchmal ist es wichtig, Dinge einmal öfter zu tun.
Bei der Java Programmierung kann es schonmal sein, dass du einen Code mehrfach ausführen lassen musst.

Zum Beispiel die Zahlen eins bis zehn.
Ein Java Programm, welches die Zahlen eins bis zehn wiedergibt.
Na wie wäre das?

Der Java Code dazu würde so aussehen:


public class ZaehlenTest {
 
public static void main(String[] args) {
int i =1;
System.out.println(i); //Startwert 1
System.out.println(++i); // i =2
System.out.println(++i); // i= 3
System.out.println(++i); // i= 4
System.out.println(++i); // i= 5
System.out.println(++i); // i= 6
System.out.println(++i); // i= 7
System.out.println(++i); // i= 8
System.out.println(++i); // i= 9 
System.out.println(++i); // i= 10
}
}

Die Methode hat im Rumpf 10 Anweisungen, welche alle genau das Gleiche machen?

Was stimmt an dieser Methode nicht?
Klar sie funktioniert.

Aber dennoch, ist es extrem viel gleicher Code.
Außerdem ist das Ganze extrem unflexibel.

Wenn du nämlich bis 5 zählen willst, brauchst du eine neue Methode.
Wenn du alle Möglichkeiten bis zur Zahl einhundert abbilden möchtest, brauchst du einhundert Methoden.
Und im Grunde genommen, machen alle diese Java Methoden das gleiche.

Wie schön wäre es doch, wenn wir eine bessere Methode hätten.
Und diese Methode erwartet einen Start- und einen Endwert.
Und dann zählt die Methode vom Startwert zum Endwert.

Na wäre doch cool, oder?
Lass uns doch so eine Java Methode einmal schreiben.

Wiederholungen implementieren mit der Java While Schleife.

Du kennst den Ausdruck Endlosschleife?

Und Schleifen in der Programmierung bezeichnen genauso so etwas.
Etwas beginnt an einen bestimmten Punkt und dann wird das Ganze immer wieder durchlaufen.

In einer Endlosschleife würde so etwas niemals enden.
Wir lassen unser Programm aber enden.
Und deshalb benötigen wir neben dem Anfangswert noch einen Endwert..

Das Java Programm soll also bei einem bestimmten Startpunkt einhaken und dann soll immer wieder der selbe Code ausgeführt werden, bis ein gewisser Endpunkt erreicht ist.

Wenn wir ein Programm schreiben würden, welches die Zahlen von eins bis zehn zählen soll.
Dann ist der Startpunkt 1 und der Endpunkt 10.

Alles klar?
Lass uns loslegen.

So eine Java While Schleife beginnt immer mit einer Bedingung

Und diese Bedingung wird nicht über if oder else ausgedrückt.
Nein. Über while.

Und was heißt das?
Frei übersetzt kann man sagen: solange.

Solange der Wert zwischen 1 und 10 ist, führe den Code immer wieder aus.
Und so eine „solange-Bedingung“ drückst du mit dem Java Keyword while aus.

Somit würde die Schleifenbedingung so aussehen:
while (1<=10)

Oder:
while (startwert<=endwert)

Der komplette Java Code würde so aussehen:


public class ZaehlenTest {
 
static void zaehle(int startwert, int endwert) {
while (startwert <= endwert) { //Schleifenbedingung
System.out.println(startwert); //Rückgabe des jeweiligen Wertes
startwert++; //Wert um eins erhöhen
}
System.out.println("fertig"); //Fertig
}
 
public static void main(String[] args) {
zaehle(1, 10);
}
}

Was macht die "Zaehlen-Methode"?
Die Java Methode erwartet zwei Parameter.
Sie bekommt beim Aufruf einen Start- und einen Endwert übergeben.
In diesem Fall ist 1 der Start- und 10 der Endwert.

Und dann geht’s los.
Die Schleifenbedingung prüft, ob der Startwert unter dem Endwert liegt.
Falls dieser Ausdruck true ist, springt die Methode in die Schleife.

Java-While-Schleifen

Im Schleifenrumpf werden zwei Anweisungen ausgeführt.
Der Startwert (1) wird per Bildschirmausgabe zurückgegeben.
Und der Startwert wird um eins erhöht (1+1).

Somit ist jetzt der Startwert nicht mehr eins, sondern schon zwei.
Und wieder prüft die while-Schleife die Bedingung.

Ja zwei ist kleiner als 10.
Also führe den Schleifenrumpf aus.
Gib den Wert des Startwertes zurück. (2)
Und erhöhe den Startwert um eins. (2+1)

Nach dem zweiten Schleifendurchlauf ist der Startwert bei 3.
Und wieder wird geprüft.
Ja 3 ist kleiner als 10.

Also wieder rein in den Schleifenrumpf.

Und das ganze geschieht solange, bis der Startwert 10 ist.

Dann ist die Schleifenbedingung
while (startwert<=endwert) false und das Programm springt nicht noch einmal in die Schleife.

Stattdessen wird dann der Code außerhalb der Schleife ausgeführt.
System.out.println("fertig");

Und somit wurde der komplette Methodenrumpf durchlaufen.
Fertig.

Zusammenfassung:

  • Falls in einer Methode ein Code immer wieder ausgeführt werden soll, nutze die while Schleife dafür.
  • Durch das Java Keyword while kannst du eine Schleifenbedingung festlegen.
    Nach jedem Schleifendurchlauf wird die Bedingung neu geprüft.
  • Falls diese nach wie vor den Wahrheitswert true liefert, springt das Java Programm immer wieder in die Schleife.
    Wenn die Schleifenbedingung nicht mehr true ist:
    Erst dann wird der restliche Code der Java Methode ausgeführt.

Ähnliche Beiträge