Was sind eigentlich verschachtelte Schleifen? Im heutigen Blogbeitrag wirst du die Antwort auf diese Frage erhalten und lernen, was du spannendes damit in deinen Programmen umsetzen kannst.
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 wir für verschachtelte Schleifen wissen müssen
In den vergangenen Beiträgen sind wir bereits auf verschiedenste Schleifenkonstrukte eingegangen. Wir haben die While Schleife, die do While Schleife und die for Schleife in Java kennengelernt. Diese benötigen wir, um für das heutige Thema vorbereitet zu sein.
Ich möchte dir in diesem Beitrag zeigen, wie wir die oben erwähnten Schleifen ineinander verschachteln können.
2. Beispiel einer verschachtelten for Schleife
Werfen wir dafür nun mal einen Blick auf das folgende Beispiel. Darin sehen wir eine for Schleife, deren Zählervariable i beim Wert 1 startet und die so lange läuft, wie i < 4 ist:
for(int i = 1; i < 4; i++) {
}
Anstatt in diesen Codeblock Anweisungen zu schreiben, definieren wir darin erneut eine for Schleife. Bei dieser nennen wir die Zählervariable j und legen die gleiche Bedingung sowie die Erhöhung der Zählervariable um 1 fest, wie wir es bereits bei der äußeren Schleife getan haben:
for(int i = 1; i < 4; i++) {
for(int j = 1; j < 4; j++) {
}
}
Wir werden das Programm jetzt so schreiben, dass wir in der Konsole das folgende Bild erhalten:
Dieses Bild sieht aus wie ein Tic-Tac-Toe-Feld, das nur aus Xen besteht. Das können wir uns mithilfe der ineinander verschachtelten for Schleife ausgeben lassen und funktioniert folgendermaßen:
Innerhalb der inneren for Schleife benötigen wir erstmal eine print-Methode.
Dabei liegt der Trick darin, nicht println zu schreiben, sondern das „ln“ wegzulassen.
Das „ln“ steht für „line“ und sorgt dafür, dass zunächst der Inhalt zwischen den Klammern ausgegeben wird und das Programm anschließend automatisch einen Zeilenumbruch setzt. Alles, was danach folgt, schreibt das Programm demnach in eine neue Zeile.
Schreiben wir hingegen nur „print“, folgt kein Zeilenumbruch. Um schon mal die innere Schleife abzuschließen, lassen wir darin einen String „x“ und ein Leerzeichen ausgeben:
for(int i = 1; i < 4; i++) {
for(int j = 1; j < 4; j++) {
System.out.print("x ");
}
}
Unter die innere Schleife schreiben wir jetzt noch eine println-Methode, führen das Programm aus und sehen, dass dadurch das gewünschte Bild herauskommt:
for(int i = 1; i < 4; i++) {
for(int j = 1; j < 4; j++) {
System.out.print("x ");
}
System.out.println();
}
Was ist in diesem Code genau passiert?
3. So wird das Tic Tac Toe Feld in die Konsole gezeichnet
Wie bereits erwähnt, haben wir es hier mit einer verschachtelten for Schleife zu tun. Darin liegt zunächst die äußere for Schleife. Diese startet bei 1 und läuft so lange durch wie i kleiner als 4 ist. Es gibt also durch die äußere Schleife insgesamt drei Schleifendurchläufe, da wir die Zählervariable immer um 1 erhöhen.
Gleichzeitig gibt es darin eine innere Schleife, welche exakt gleich aufgebaut ist, nur dass die Zählervariable j heißt. Auch bei dieser haben wir drei Schleifendurchläufe.
Das Ganze funktioniert jetzt folgendermaßen:
Wir starten mit dem ersten Durchlauf in der äußeren Schleife. Von dort aus bewegen wir uns direkt in die innere for Schleife. Dann gibt das Programm einmal „x “ aus.
Die Schleife ist an dieser Stelle aber noch nicht vorbei, da j erst einmal auf den Wert 2 erhöht wird. Weil 2 immer noch kleiner ist als 4, gibt das Programm ein weiteres Mal „x “ auf der Konsole aus.
Danach erhöht sich j auf 3, was noch immer kleiner als 4 ist und dazu führt, dass ein drittes Mal „x “ ausgegeben wird. Auf diesem Weg kommt die erste Zeile zustande:
Wie bereits gesagt: Da wir das „ln“ in der print-Methode weggelassen haben, werden die Xe nebeneinander geschrieben und der Zeilenumbruch bleibt aus.
Sobald die innere Schleife erfolgreich durchlaufen ist, geht es mit der println-Methode darunter weiter. Darin übergeben wir nichts, wodurch es im Programm lediglich zu einem Zeilenumbruch kommt und wir uns in der zweiten Zeile des Bildes befinden:
Jetzt bewegt sich das Programm wieder oben in die äußere Schleife, da deren gesamter Block einmal durchlaufen ist. Die Zählervariable i erhöht sich und hat damit nun den Wert 2. Da 2 kleiner als 4 ist, startet die innere Schleife wieder und wir erhalten am Ende unser Tic-Tac-Toe-Bild mit drei Reihen und je drei Kreuzen.
Auf diese Art kann man also mit verschachtelten Schleifen arbeiten!
Das war natürlich nur ein einfaches Beispiel ohne tieferen Sinn, bei welchem wir lediglich Xe ausgegeben haben. Ich wollte dir damit demonstrieren, dass wir sämtliche Schleifen, die wir bereits kennengelernt haben, beliebig oft ineinander verschachteln können.
Das heißt, wir könnten beispielsweise in die innere for Schleife eine weitere Schleife einbauen, wie etwa eine while Schleife.
Wie du in der Zukunft merken wirst, wird es an vielen Punkten deiner Programmierlaufbahn sinnvoll sein, Schleifen zu verschachteln.
Abschließend möchte ich noch kurz darauf eingehen, worauf du beim Verschachteln von Schleifen achten solltest.
4. Variablen sind nicht überall gültig
Zum einen musst du darauf achten, dass die Gültigkeit der Variablen ausreicht. Was meine ich damit?
Um das zu veranschaulichen, definiere ich nun eine Variable, nenne sie „test“ und initialisiere sie mit dem Wert 0.
int test = 0;
Die Variable ist an dieser Stelle definiert und wir können sie überall in diesem Programm verwenden.
Genauer gesagt können wir sie da verwenden, wo wir sie definiert haben. Und zwar im entsprechenden Block.
Im Fall unseres Beispiels startet der Block oben und geht bis hin zur vorletzten geschlossenen geschweiften Klammer. Wir können die Variable also im ganzen Programm verwenden:
Auch wenn wir Schleifen ineinander verschachteln und es damit tiefer hineingeht, ist diese Variable noch immer verwendbar und wir können mit ihr arbeiten.
Sehen wir uns das Ganze nun mal an.
Wir haben eine for Schleife, bei welcher sich ein neuer Block öffnet. Dieser startet und endet an den im Bild markierten Stellen:
Oben in den runden Klammern der Schleife definieren wir die Integer-Variable i. Wenn wir die Zählervariable im Kopf definieren, zählt sie so, als wäre sie im Block definiert worden.
Diese Variable i ist jetzt innerhalb des Blocks sichtbar. Sobald dieser allerdings zu Ende ist, zerstört das Programm sie und macht sie damit ungültig.
Das können wir ganz einfach überprüfen, indem wir versuchen, unter dem Schleifenblock i ausgeben zu lassen.
Wie wir sehen, erhalten wir direkt eine Fehlermeldung.
Das liegt daran, dass i an dieser Stelle im Code gar nicht mehr existiert. Weil das Programm sie zerstört, sobald es den Block verlassen hat.
Das ist eine wichtige Information, auf die du immer achten solltest.
Aus diesem Grund kann man in der inneren Schleife „j“ nicht auch als „i“ bezeichnen. Denn darin ist die Variable i, die zur äußeren Schleife gehört, noch gültig. Würden wir „j“ also auch als „i“ bezeichnen, wüsste der Computer nicht mehr, auf welche Variable i wir uns beziehen.
Das heißt: Sobald du Schleifen verschachtelst, musst du natürlich auch die Zählervariablen anders benennen, da der Computer sonst nicht mehr weiß, um welche Variable es sich in der jeweiligen Situation handelt.