Nachdem wir uns bereits mit dem if..then..else und dem switch Konstrukt beschäftigt haben, wollen wir uns jetzt mit einer weiteren wichtigen Kontrollstruktur befassen!
Und zwar den Schleifen!
Du kennst das sicher!
Du hast dir bei Chefkoch ein Kochrezept besorgt, in welchem steht: "Schlagen Sie ein Ei auf!"
Kim, wo hast du denn bitte deine Kochrezepte her?
Natürlich, wird das so nicht im Rezept stehen!
Vielmehr wird die Anweisung "Schlagen Sie drei Eier auf!" lauten.
Na toll!! Jetzt redest du übers Kochen! Hallo Kim klopf, klopf hast du vielleicht vergessen, dass wir große Programmierer werden wollen?
Ganz ruhig!!
Wir werden sehr oft in der Situation sein, dass wir in einem Programm eine Anweisung mehr als einmal ausführen müssen.
Stell dir einen Raum mit 20 Personen vor!
Wir möchten gerne jede Person nach ihrem Namen fragen. Die schlechte Vorgehensweise wäre es, das mit 20 Einzelanweisungen zu bewerkstelligen.
System.out.println("Person 1 wie heißen Sie?"); System.out.println("Person 2 wie heißen Sie?"); ... System.out.println("Person 20 wie heißen Sie?");Viel besser wäre es doch, wenn wir eine Anweisung von der Art "Frage alle 20 Personen nach ihren Namen!" geben könnten.
Und genau das können wir mit Hilfe der Schleifen-Kontrollstrukturen erreichen!
Die for Schleife in Java!
Schauen wir uns mal folgenden Programmschnipsel an:
for(int i = 1; i <= 20; i++) { System.out.println("Person " + i + " wie heißen Sie?"); }Ich weiß, ich gehe dir mit dieser Frage auf den Schnürsenkel. Aber nur Übung macht den Meister! Hast du eine Idee, was dieses kleine Programm macht?
Korrekt! Du bist richtig gut!
Das Programm stellt 20-mal die Frage "Person i wie heißen Sie?" Hierbei nimmt die Variable i jeden Wert zwischen 1 und 20 an. Die Programmausgabe lautet:
Person 1 wie heißen Sie? Person 2 wie heißen Sie? ... Person 20 wie heißen Sie?Der Trick hierbei ist die Verwendung einer sogenannten for-Schleife!
Nun, wie funktioniert das Ganze?
Einprägsamerweise beginnt eine for Schleife immer mit dem Schlüsselwort for.
Zwischen den beiden runden Klammern stehen drei Elemente, die jeweils durch ein Simikolon voneinander getrennt sind.
Im ersten Teil definieren wir eine Zählervariable i, der wir den Wert eins zuweisen.
Teil zwei der Schleifendefinition ist die Bedingung i <= 20. Solange diese erfüllt ist, wird im dritten Teil die Zählervariable i um eins erhöht und die Anweisung System.out.println("Person " + i + " wie heißen Sie?") ausgeführt.
Die Anweisung i++ nennt der Fachmann Inkrement, womit nichts anderes als die Erhöhung der Variablen i um eins gemeint ist.
Wir hätten also genauso gut auch i = i + 1 schreiben können.
Natürlich ist es sinnvoll, dass die Zählervariable eine ganze Zahl, also vom Datentyp Integer ist. Dazu zwingt uns aber niemand.
Wir können auch eine Variable vom Typ double als Zählervariable verwenden. Schau dir folgendes Beispiel an:
for(double d=0.5; d <= 10; d += 0.5) { System.out.println("Person " + d * 2 + " wie heißen Sie?"); }Steigst du dahinter, was das Programm macht?
Richtig! Auch hier werden wieder 20 Personen nach ihrem Namen gefragt. Die Programmausgabe ist:
Person 1.0000 wie heißen Sie? Person 2.0000 wie heißen Sie? ... Person 20.0000 wie heißen Sie?Der einzige Unterschied zu der Programmausgabe von oben ist, dass hier der Zähler als Dezimalzahl mit trennendem Punkt ausgegeben wird. Das liegt einfach daran, dass unsere Zählervariable d eine Variable vom Datentyp double ist.
Wir initialisieren die double Variable d im Zuweisungsteil der Schleife mit 0.5 und erhöhen diese in jedem Schleifendurchlauf um den Wert 0.5. Das machen wir solange, bis d den Wert 10 erreicht hat.
Wir haben also auch hier wieder 20 Schleifendurchläufe. Indem wir mit dem Faktor 2 multiplizieren, verpassen wir der Variablen d noch etwas Schminke. Das machen wir, weil wir keine halben Personen ansprechen wollen.
Die while Schleife in Java!
Bei der Kontrollstruktur for-Schleife legen wir durch die Initialisierung der Zählervariablen (im Beispiel i=1) und der Abbruchbedingung (im Beispiel i <= 20) vor dem Start der Schleife fest, wie oft die Anweisungen zwischen den geschweiften Klammern wiederholt werden sollen.
Das ist in vielen Fällen aber viel zu unflexibel!
WARNUNG! Es gibt Programmierer, die im Schleifenrumpf der for-Schleife (der Teil, der zwischen den geschweiften Klammern steht) die Zählervariable ändern und damit die Anzahl der Schleifendurchläufe während der Schleifenlaufzeit verändern. Ich bitte dich! MACH DAS NIE!! Das macht deine Programme nur unverständlich!
Stell dir vor! Peter hat ein Blinddate mit Franka!!
Peter hat keine Ahnung, wie Franka aussieht. Er weiß nur, dass das Date in der neuen hippen Szene Bar am Stadtrand stattfindet. Genau da, wo sich die ganzen coolen Programmierer rumtreiben.
Peter bleibt nichts anderes übrig, als sich solange durchzufragen, bis er Franka gefunden hat. Und genau hierbei hilft ihm eine Kontrollstruktur namens while Schleife. Schau dir mal folgendes Programm an:
boolean frankaGefunden = false; InputStreamReader isr = new InputStreamReader(System.in); BufferedReader br = new BufferedReader(isr); while(frankaGefunden == false) { System.out.println("Entschuldigung, bist du Franka? Ja/Nein"); String antwort = br.readLine(); if (antwort.equals("Ja")) { frankaGefunden = true; } } System.out.println("Hallo, ich bin Peter. Schön dich kennenzulernen!");Wir wollen uns hier nicht so sehr mit den Details beschäftigen. In den Zeilen zwei, drei und sechs verwenden wir Eingabestreams, mit welchen wir uns noch in einem eigenen Artikel beschäftigen werden. Auch wollen wir uns nicht so sehr über die Bedingung in der if-Abfrage aus Zeile sieben den Kopf zerbrechen.
Was macht das Programm?
Das Programm gibt solange die Frage "Entschuldigung, bist du Franka? Ja/Nein" auf dem Bildschirm aus, bis die Bildschirmeingabe Ja lautet. Danach endet das Programm mit der Bildschirmausgabe "Hallo, ich bin Peter. Schön dich kennenzulernen!".
Kim, das ist geil! Wie funktioniert das?
Zunächst deklarieren wir gleich in der ersten Zeile eine boolesche Variable frankaGefunden.
In Zeile zwei beginnt die while Schleife. Durch diese Kontrollstruktur wird der Programmcode zwischen den geschweiften Klammern (Zeile vier und neun) solange ausgeführt, bis die Bedingung zwischen den runden Klammern nicht mehr erfüllt ist.
In unserem Beispiel ist die Bedingung solange erfüllt, bis die Antwort auf die Frage "Entschuldigung, bist du Franka? Ja/Nein" Ja lautet. Dann ist die if-Bedingung in Zeile sieben erfüllt und die Variable frankaGefunden erhält in Zeile acht den Wert true. Die Bedingung frankaGefunden == false im Bedingungsteil der while Schleife ist nicht mehr wahr, weshalb der Programmcode innerhalb der Schleife (Zeile fünf bis acht) nicht mehr ausgeführt wird und das Programm mit der Ausgabe "Hallo, ich bin Peter. Schön dich kennenzulernen!" endet.
Merke! Bei der while Schleife wird die Bedingung direkt am Anfang überprüft, deshalb kann es passieren, dass der Anweisungsteil dieser Kontrollstruktur kein einziges Mal ausgeführt wird.
In unserem Beispiel wäre das der Fall, wenn wir die Variable frankaGefunden mit true initialisiert hätten.
Deshalb gibt es noch einen weiteren Schleifentyp, nämlich die sogenannte do-while Schleife.
Die do-while Schleife in Java
Okay, lass uns nicht labern, lassen wir lieber den Quellcode sprechen!
boolean frankaGefunden = false; InputStreamReader isr = new InputStreamReader(System.in); BufferedReader br = new BufferedReader(isr); do { System.out.println("Entschuldigung, bist du Franka? Ja/Nein"); String antwort = br.readLine(); if (antwort.equals("Ja")) { frankaGefunden = true; } } while(frankaGefunden == false); System.out.println("Hallo, ich bin Peter. Schön dich kennenzulernen!");Okay, was denkst du? Was macht dieses Programm?
Korrekt!
Das gleiche wie unser Programm von oben! Auch hier wird wieder solange die Frage "Entschuldigung, bist du Franka? Ja/Nein" gestellt, bis die Antwort Ja lautet.
Allerdings wird die Bedingung frankaGefunden == false erst am Ende der Schleife geprüft, sodass der Anweisungsteil der Kontrollstruktur (Zeile fünf bis acht) mindestens einmal ausgeführt wird.
Merke! Der Anweisungsteil einer do-while Schleife wird mindestens einmal ausgeführt!
Wann solltest du welchen Schleifentyp verwenden?
Da wir bei der for-Schleife einen festen Startwert und eine feste Endbedingung haben, solltest du diese Kontrollstruktur immer dann einsetzen, wenn du bereits weißt, wie oft die Ausführung eines Anweisungsblocks wiederholt werden soll.
Die while und do-while Schleifen werden deutlich flexibler verwendet, da bei jedem Schleifendurchlauf neu entschieden wird, ob eine weitere Wiederholung des Anweisungsteils stattfinden soll oder nicht.
Die Unterschiede zwischen der while und der do-while Kontrollstruktur sind eher geringfügig.
In der while Schleife entscheidest du zu Beginn, noch vor dem Anweisungsteil, ob ein (weiterer) Schleifendurchlauf erfolgen soll. Bei der do-while Schleife steht die Bedingung hingegen am Ende, weshalb du erst am Schluss entscheidest, ob ein weiterer Durchlauf stattfinden soll.
Meist ist es Geschmackssache, ob du eine while oder eine do-while Kontrollstruktur verwendest.
Typisches Anwendungsgebiet einer do-while Schleife ist das zeilenweise Einlesen einer Textdatei. Hier musst du nach jeder eingelesenen Zeile prüfen, ob die Datei bereits vollständig eingelesen wurde oder ob noch weitere Zeilen folgen und weitere Schleifendurchläufe erforderlich sind.
Ein gutes Beispiel für die Anwendung einer while Schleife ist eine Kreuzung im Straßenverkehr. Hier solltest du zu deiner eigenen Sicherheit erst die Ampel überprüfen (Bedingung) und erst danach die Kreuzung überqueren (Anweisungsteil).
Damit haben wir alle Kontrollstrukturen in Java kennengelernt.
Wie immer freue ich mich über deine Fragen im Kommentarbereich!
Hat dir der Artikel gefallen?
