Schleifen

Schleifen

Bei einer Schleife (engl. Loop) handelt es sich um Kontrollstrukturen, die eine oder mehrere Anweisungen beliebig oft ausführen können. Eine Schleife wiederholt einen Anweisungs-Block solange eine gegebene Schleifenbedingung als Laufbedingung der Schleife gültig bleibt und keine Abbruchbedingung eingetreten ist. Schleifen können beliebig oft ineinander verschachtelt werden, was eine sehr umfangreiche Prüfung von komplexer Bedingungen ermöglicht.
 
Ein Beispiel: Wir haben etwas verloren und suchen danach. Wir haben aber höchstens 10 Minuten Zeit.
Somit durchlaufen wir diese „Schleife“ immer und immer wieder, indem wir den selben Vorgang des Suchens dauernd wiederholen. Diesen Vorgang brechen wir in unserem Fall nur ab, wenn entweder die Laufbedingung erfüllt ist, sprich wir gefunden haben, wonach wir suchten, oder die Abbruchbedingung eintritt. In diesem Fall wäre das die Überschreitung der 10 Minuten Frist.

 

Es gibt verschiedene Arten von Schleifen:

  • while-Schleife
  • do-while-Schleife
  • for-Schleife

Außerdem gibt es noch Endlosschleifen, die möchten wir hier aber nicht behandeln, früher oder später wird dir das automatisch passieren.
Eine Endlosschleife bedeutet, dass man da nie wieder raus kommt, die einzige Lösung ist: das Programm abzubrechen.

while-Schleife:

Aufbau einer while-Schleife:

while(Bedingung){
      Befehle_die_mehrfach_ausgeführt_werden_sollen();
}

Ablauf:

Zunächst wird geprüft, ob die Bedingung erfüllt ist.
Ist dies der Fall, werden die Befehle im Schleifenrumpf einmal ausgeführt.
Im Anschluss wird erneut geprüft, ob die Bedingung noch erfüllt ist.
Ist dies der Fall, werden die Befehle im Schleifenrumpf einmal ausgeführt.
...
Ist die Bedingung nicht erfüllt, springt das Programm zum nächsten Befehl nach der Schleife.

Hier noch ein Programm-Code Beispiel, um es verständlicher zu machen.

int i=0;
while(i<5){
    System.out.println("Zahl:" + i);
    i++;
}

 

do-while-Schleife:

Aufbau einer do-while-Schleife:

do{
      Befehle_die_mehrfach_ausgeführt_werden sollen();

}while (Bedingung);

Ablauf:

Im Gegensatz zur einfachen while-Schleife werden hier die Befehle auf jeden Fall mindestens einmal ausgeführt.
Danach wird geprüft, ob die Bedingung erfüllt ist: Wenn ja, wird der Befehl nochmals ausgeführt und so weiter.
Wenn nein, dann springt das Programm zum nächsten Befehl nach der Schleife.

Dazu wieder ein Code Beispiel:

int i=0;
do{
         System.out.println("Zahl: " + i);
          i++;
} while(i<5);

 

Nochmals zur Verdeutlichung und der Unterschied:

Bei der while-Schleife, die sogenannte abweisende Schleife, kann (wie der Name schon sagt) es sein, dass gar kein Befehl im Schleifenrumpf ausgeführt wird. Da erst die Bedingung überprüft wird (noch vor der ersten Ausführung) und wenn diese schon nicht stimmt, dann passiert auch nichts.
Bei der do-while-Schleife, die sogenannte nicht-abweisende-Schleife wird mindestens einmal etwas ausgeführt, da erst hinterher überprüft wird (erst nach der ersten Ausführung), ob der Befehl nochmals ausgeführt werden soll.

for-Schleife:

Aufbau einer for-Schleife:

for (Initialisierung; Bedingung; Updateliste){
     Befehle_die_mehrfach_ausgeführt_werden sollen();
}

Bei der Inititalisierung wird eine Variable initialisiert, das heißt es wird ihr einen Wert zugewiesen.
Die Bedingung wird durch ein Semikolon getrennt festgelegt, dort wird immer geprüft, ob die Bedingung erfüllt ist (true = wahr) oder nicht (false = falsch).
Sollte die Bedingung erfüllt sein, werden die Befehle ausgeführt und danach wird zusätzlich die Anweisung in der Updateliste ausgeführt.
Um dir zu verdeutlichen, was genau es damit auf sich hat, hier ein Beispiel:

for (int i = 0; i < 5; i++){

    System.out.println("Zahl: " + i);

}

In dieser Schleife wird also eine Variable namens "i" initialisiert, diese ist vom Typ Integer (das ist einfach gesagt eine Ganzzahl). Danach steht die Bedingung: i < 5: Die Schleife wird also so lange ausgeführt, wie "i" kleiner als 5 ist.

  • Im ersten Durchgang hat i den Wert 0, das heißt die Bedingung ist wahr/true. Und es wird ausgegeben: Zahl: 0. Dann wird i durch "i++" eins hochgezählt.
  • Im zweiten Durchgang hat i also den Wert 1, das heißt die Bedingung ist immer noch wahr/true. Und es wird ausgegeben: Zahl: 1. i wird wieder um eins hochgezählt.
  • Im dritten Durchgang hat i den Wert 2, das heißt die Bedingung ist wahr/true. Und es wird ausgegeben: Zahl: 2. i wird wieder um eins hochgezählt.
  • Im vierten Durchgang hat i den Wert 3, das heißt die Bedingung ist wahr/true. Und es wird ausgegeben: Zahl: 3. i wird wieder um eins hochgezählt.
  • Im fünften Durchgang hat i den Wert 4, das heißt die Bedingung ist wahr/true. Und es wird ausgegeben: Zahl: 4. i wird wieder um eins hochgezählt.
  • Im sechsten Durchgang hat i den Wert 5, das heißt die Bedingung ist falsch/false, da i nun nicht mehr kleiner als 5 ist. An dieser Stelle wird die Schleife also beendet und das Programm springt zum nächsten Befehl nach der Schleife.