For Schleifen im Java Programm schachteln: So funktioniert es

Schlagwörter: Java Programmierung, Java Schleifen

Die Java For Schleife am Beispiel eines Uhrwerkes.

So ein Uhrwerk besteht aus verschiedenen Zahnrädern, welche in einer bestimmten Beziehung stehen.

Wie du sicherlich siehst….
Die Zahnräder einer Uhr sind unterschiedlich groß.

Und diese unterschiedliche Größe ist enorm wichtig.

Denn dadurch werden bestimmte Umdrehungsanzahlen (blödes Wort) von einem Rad auf das Nächste übergeben.

So kannst du dir eine geschachtelte Java For Schleife am Beispiel vorstellen.

Wir bleiben vorerst bei der Uhr.
Denn dieses gedankliche Modell ist prädestiniert, um Schachtelung in Java For Schleifen darzustellen.
 
Wir sagten:

• Stundenzeiger bzw. Stundenzahnrad 1 Umlauf
• Minutenzeiger bzw. Minutenzahnrad 60 Durchläufe

Du benötigst also eine innere und eine äußere Schleife.
Und die innere For Schleife wird vollständig von der äußeren Schleife umfasst.

So kannst du for Schleifen in Java schachteln

Beginnen wir mit der äußeren Schleife – der Stundenanzeige.
 
Im Kopf befindet sich die Zählvariable, welche bei 0 startet.
Somit lautet diese int i = 0

• 1. Durchlauf i = 0
• 2. Durchlauf i = 1
• 3. Durchlauf i = 2
• 4. Durchlauf i = 3
• 24. Durchlauf i =23

Nach 24 Durchläufen hat i den Wert 23.
Die Abbruchbedingung "i < 24" ist erfüllt und somit wäre ein neuer Durchlauf nicht möglich. Und so sieht der Java Code zur äußeren for Schleife aus.

public class JavaForFor {

	public static void main(String[] args) {

		for (int i = 0; i < 24; i++) {
			System.out.println(i);

		}
	}
}

Ich habe dazu eine neue Klasse angelegt.
Die for-Schleife habe ich gleich in die main-Methode implementiert.
Somit startet die Schleife gleich und immer beim Programmstart.
 
PS:
Im Schleifenrumpf habe ich eine Bildschirmausgabe zu "i" integriert.
Diese soll lediglich eine Kontrolle sein, ob alle Stundenzahlen ordnungsgemäß angezeigt werden.
Später - macht dies komplett die innere Schleife.
 

Na dann schauen wir uns die innere Schleife einmal an.

Beginnen wir wieder beim Aufbau und somit beim Schleifenkopf.

Also dann...
So sehen dann die Schleifendurchläufe in der Theorie aus:

• 1. Durchlauf j = 0
• 2. Durchlauf j = 1
• 3. Durchlauf j = 2
• 60. Durchlauf j = 59

Im Schleifenrumpf soll jetzt eine Bildschirmausgabe die Zeitzählung ausgeben.
Dazu werden:

• "I" - Zählvariable aus der äußeren Schleife
• Und "j" - die Zählvariable aus der inneren Schleife ausgeben.
• Schick gemacht mit etwas Standardtext und fertig.

So sieht der Java Code für zwei geschachtelte for Schleifen aus:

public class JavaForFor {

	public static void main(String[] args) {

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

			for (int j = 0; j < 60; j++) {
				System.out.println("ZEIT: " + i + ":" + j);
			}//Ende innere Schleife
		}//Ende äußere for Schleife
	}//Ende der Main-Methode
}//Ende der Java Klasse

Klicke auf "RUN" und genieß die Show.
 

Achte bei geschachtelten Java Schleifen stets auf die Zählvariablen.

Es handelt sich immer um lokale Variablen.
Und diese existieren immer nur innerhalb der Programmstrukturen - in welcher sie auch angelegt worden.
 
Ich mach dies einmal am Bild deutlich.

public class JavaForFor {

	public static void main(String[] args) {

		for (int i = 0; i < 24; i++) {
			System.out.println(j);//Fehler denn j existiert noch nicht
			
			for (int j = 0; j < 60; j++) {
				System.out.println("ZEIT: " + i + ":" + j);
				
			}//Ende der inneren Schleife - j wird zerstört
			
			System.out.println(j);//Fehler denn j existiert nicht mehr
		}
	}
}

Natürlich kannst du den Schleifenzähler auch rückwärts zählen lassen.

Stichwort Timer - Die Zeit läuft rückwärts ab.
 
Wie bei jeder for-Schleife kannst du natürlich eine oder beide Zählvariablen auch runterzählen lassen.
Du beginnst bei 60 und endest bei 0.
 
So sieht das Ganze dann aus.

public class JavaForFor {

	public static void main(String[] args) {

		for (int i = 0; i < 24; i++) { 
                    for (int j = 60; j >= 0; j--) {
			System.out.println("ZEIT: " + i + ":" + j);

			}
		}
	}
}

Probiere es selbst aus und klicke auf "RUN".
 
Was habe ich verändert?
Die äußere Schleife bleibt gleich.
Aber die innere Schleife startet jetzt nicht bei "j=0", sondern bei "j=60".
 
Die Schleifenbedingung habe ich ebenfalls verändert.
Ursprünglich lautete diese: "j<60". Jetzt soll "j" solange heruntergezählt werden, bis "j >= 0".
 
Und natürlich darf nach jedem Schleifendurchlauf nicht mehr nach oben gezählt werden.
Sondern "J" muss kleiner werden.
Aus "j++" wurde "j--".
 
Cool, oder?
Aber da geht noch mehr…
 

Diese Java For Schleifen Schachtelung kannst du auch mit unterschiedlichen Datentypen vollziehen.

Ich führe nochmal ein zweites – komplett neues Beispiel ein.
Und zwar ein Inhaltverzeichnis.
 
Der Aufbau könnte so aussehen:
Kapitel 1
Kapitel 1 A
Kapitel 1 B
Kapitel 1 C
 
Später dann geht es mit dem zweiten Kapitel weiter:
Kapitel 2
Kapitel 2 A
Kapitel 2 B
 
Und immer so weiter.
Das letzte Kapitel lautet: Kapitel "100 Z".
 
Also was brauchen wir dafür?
Wieder zwei for-Schleifen.
 
Die äußere for-Schleife zählt die Kapitel von 1 bis 100.
Und die innere for Schleife ergänzt die Buchstaben.
 
Da jeder Buchstabe lediglich nur ein Schriftzeichen ist, kannst du einen Character-Datentyp für die innere Schleife verwenden.
In einer früheren Übung haben wir dies schon einmal umgesetzt.
 
Hier die zwei Schleifen:

public class JavaForFor {

	public static void main(String[] args) {

		for (int i = 1; i <= 100; i++) {
			for (char zeichen = 65; zeichen <= 90; zeichen++) {
				System.out.println("Kapitel: " + i + " " + zeichen);
			}
		}
	}
}

Die äußere Schleife ist klar, oder?
 
Die innere Schleife beginnt bei char zeichen = 65.
Und zwar deshalb, weil hinter diesem internen "Char-Index" das große "A" steckt.
 
Das ganze endet dann bei char zeichen <=90.
Denn hier steckt das große "Z".
 
Klicke auf "RUN" und genieße die letzte Konsolenausgabe für heute.
Ich hoffe- du hattest Spaß.
 

Zusammenfassung:

• Bei der Java Programmierung kannst du for Schleifen schachteln.
• Dies ist mitunter sehr hilfreich um eine bestimmte Anzahl an inneren Schleifendurchläufen zu erzwingen.
• Dazu musst du lediglich, im Inneren einer bereits bestehenden for-Schleife, eine zweite for-Schleife einfügen.
• Achte dabei unbedingt auf die lokale Zählvariable.
  Denn - Wie in jedem anderen Programmkonstrukt existieren lokale Variablen nur innerhalb der for-Schleife, in welcher sie angelegt worden sind.