Skip to main content

Java for Schleifen schachteln – So funktioniert es

Diese Situation kennst du doch auch….
Du stehst an der Haltestelle und wartest auf den Bus.
Dein Blick fällt auf die Uhr.
 
Oder du wartest an der Ecke auf deinen Freund oder Kollegen.
Immer wieder schaust du auf deine Uhr.
 
Sie ist kaum noch wegzudenken.
Die mobile Taschenuhr.
 
Lange Zeit wurde die Erfindung der Taschenuhr dem deutschen Schlossermeister Peter Henlein zugeschrieben.
Heute glauben Historiker, dass die Wurzeln der Taschenuhr – viel weiter zurückliegen.
 
Dennoch gehören die Henlein-Uhren zu den ältesten erhaltenen Exemplaren.
Und die deutschen Städte Augsburg und Nürnberg wurden, im 16 Jahrhundert, zu echten Hochburgen der Uhrmacherkunst.
 
Aber wie funktioniert eigentlich so eine Taschenuhr?
Und was hat das Ganze Uhrwerk mit Java for Schleifen zu tun?
 
Diese beiden Fragen möchte ich in diesem Beitrag beantworten.
Es bleibt also spannend.

Die Java For Schleife am Beispiel eines Uhrwerkes.

Taschenuhr

Taschenuhr Quelle: Amazon

Schau dir einmal das Bild zur Uhr an.

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.

Java for Schleife Zahnräder

Im Klartext bedeutet dies.
Wenn sich das große Zahnrad einmal dreht, drehen sich die kleineren mehrmals.
 
Und wie oft bei einer Uhr?
Angenommen das große Rad hängt am Stundenzeiger der Uhr.
Und das nächst kleinere Zahnrad hängt am Minutenzeiger der selben Uhr.
 
Bei jeder Drehung des großen Rades (1 Stunde) müsste sich das kleine Rad – genau 60-ig mal drehen. (1 Stunde = 60 Minuten).
 
Wie kannst du dies in einem Java Programm simulieren?
Klar mit Schleifen – am besten mit for Schleifen.
 

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.

Java for Schleifen schachteln Aufbau

Die Grenzen sind somit klar abgesteckt.
 
Doch was passiert jetzt in den geschachtelten For Schleifen?
Immer wenn in der äußeren Schleife ein Durchlauf stattfindet – finden in der inneren Schleife 60 Durchläufe statt.
Dies entspricht dann der Umrechnung von Stunde zu Minuten.
Klar, oder?
Java for Schleifen schachteln Aufbau Durchlauf

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

Java for Schleifen schachteln äußere Schleife Aufbau

Die Schleife soll solange durchlaufen werden, bis i den Wert 23 hat.
24 Stunden ist ein Tag.
Und deshalb lautet die Schleifenbedingung: i < 24
Java for Schleifen schachteln Schleifenbedingung

Selbstverständlich wird i nach jedem Durchlauf um eins erhöht.
i++ 
Java For Schleifen schachteln Inkrementierung

Somit würde i bei 24 Durchläufen folgende Werte haben:

  • 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.

Java For Schleifen Schachtelung

Wie du auf dem Bild sehen kannst….
Die äußere Schleife (schwarzer Code) umschließt komplett die innere Schleife.
 
Jetzt kümmern wir uns nur noch um den inneren Schleifenkopf.
Und zwar nach genau dem gleichen Muster.
 
Die Zählvariable startet bei 0.
Diese nenn ich "j", da der Name "i" bereits vergeben ist.
Stichwort - Shadowing.
 
Somit beginnt der Schleifenkopf auch hier mit: int j = 0.
Java for Schleifen schachteln Innere Klasse Zählen

Die Schleifenbedingung lautet: j < 60.
Somit musst du die Skalierung von 24 auf 60 ändern.
Java for Schleifen schachteln Innere Schleife Schleifenbedingung

Somit generiert die Schleife 60 Durchläufe.
Nach jedem Durchlauf wird die Variable "j" um eins erhöht.
Java for Schleifen innere Schleife Inkrement

Wie du sicherlich bemerkt hast...
Die Beschreibung im Bild müsste lauten, bis "j = 59" ist.

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.

Java For Schleifen schachteln äußere lokale Variable

"I" wurde in der äußeren Schleife angelegt.
Und da die innere Schleife ein Teil der äußeren Schleife ist, existiert "I" auch in dieser.
 
"J" hingegen wurde in der inneren Schleife angelegt.
Und existiert nur in dieser Programmstruktur.
Java For Schleifen schachteln innere lokale Variable

Die Klammer, welche die innere Schleife schließt - bewirkt somit, dass "j" zerstört wird.
Du kannst somit "j" nicht in der äußeren Schleife nutzen bzw. auf "j" zugreifen.
 
So etwas wie das hier funktioniert somit nicht:

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.

Ähnliche Beiträge

3 Möglichkeiten um Vererbung von Java Klassen zu verhindern, zu verbieten oder ausschließen

Java Vererbung verhindern

Die ganze Java Vererbung für bestimmte Klassen ausschließen bzw. verhindern oder verbieten. Was soll das? Für bestimmte Java Klassen soll die Vererbung ausgeschlossen werden. Es soll also verhindert werden, dass Elternklassen – Kindklassen bekommen können. Klingt ein bisschen wie Verhütung, oder? Denn wie auch im echten Leben, können Kinder zu kleinen Tyrannen werden. Sie bedienen […]

Java Methoden mit variabler Argumentenanzahl – VarArgs

Java Methoden mit variabler Argumentenanzahl VarArgs

Du kennst das noch. Kopfrechnen und zwar auf Zeit. So etwas ist das Standardprogramm in den Schulklassen 1 bis 5. Irgendwann, in Klasse 6 oder 7, kommt der Taschenrechner ins Spiel und Kopfrechnen ist aus dem Schulalltag gestrichen. Schade eigentlich. Dabei kann man diese Disziplin auch wunderbar in kleinen Spielen unterbringen. Ich erinnere mich noch: […]

Die vier wichtigen Phasen um Java Objekte zu erstellen

Java Objekte anlegen

Wie werden aus deinen Java Klassen richtig nützliche Java Objekte? Das ganze läuft in vier Phasen ab. Und diese Phasen möchte ich dir in diesem Beitrag vorstellen. Ob das nützlich ist? Schau dir das Bild an. Am Ende dieses Beitrages wirst du wissen, warum Eclipse dir hier eine Fehlermeldung gibt und wie du dieses Problem […]

So verwendest du Inkrement und Dekrement Operatoren in deinen Java Programmen

Java Operatoren

In diesem Beitrag geht es um Java Operatoren. Ich möchte dir gern zwei neue Operatoren vorstellen. Diese nennen sich Inkrement und Dekrement. Ja was heißt das? Inkrementieren bedeutet eine schrittweise Erhöhung einer Zahl. Und dementsprechend bedeutet Dekrementieren: Die schrittweise Verminderung einer Zahl. Wozu brauchst du das? Stell dir vor. Du bekommst eine Liste mit Namen […]

Java For Each Schleife – Aufbau und Funktionsweise

Java for each Schleife

In einer anderen Lektion habe ich dir bereits gezeigt, wie du ein Java Array mit einer for-Schleife füllen und dir später die Werte zurückgeben lassen kannst. Es gibt allerdings einen weiteren Schleifentyp, welche geradezu prädestiniert ist für Java Arrays. Dieser Schleifentyp nennt sich for each Schleife. In diesem Beitrag möchte ich dir zeigen, wie du […]

So kannst du zweidimensionale Java Arrays anlegen und nutzen

Java Arrays zweidimensional

Eines der bedeutendsten Instrumente in der Mathematik ist das Koordinatensystem. Die gedankliche Grundlage dieses Werkzeuges lieferte der französische Naturwissenschaftler und Philosoph Rene Descartes. Man muss sich einmal verdeutlichen, was dies für die damalige Zeit bedeutete. Bisher wurden mathematische Probleme lediglich durch Berechnungen gelöst. Denke an geometrische Figuren, wie Dreiecke und Vierecke. Der Umfang wurde lediglich […]

So kannst du Java Arrays mit for Schleife füllen und auslesen

Java Arrays For Schleife

Wir haben in einem anderen Beitrag bereits über Java Arrays gesprochen. So ein Array speichert Zahlen, Texte oder Objekte in eine Art Liste. Und dann kannst du ganz bequem über den Index das Array füllen und die bereits enthaltenen Werte abrufen. Ganz bequem? So, wie ich dich aus dem letzten Beitrag entlassen habe, war das […]

So kannst du Werte aus zwei oder mehreren Java Arrays verrechnen.

Java Arrays verrechnen

Wie kann man Werte aus zwei oder mehreren Java Arrays miteinander verrechnen? Zum Beispiel: Du möchtest alle Werte des ersten Arrays mit allen Werten des zweiten Arrays addieren Oder du möchtest die Summe aus beiden Arrays wissen und erst dann diese miteinander addieren. Was erwartet dich in diesem Beitrag? Zuerst werde ich dir zeigen, wie […]

Nutze die Fernbedienung für deine Java Objekte

Auf Java Objekte greifst du mit einer Art Fernsteuerung zu. Diese bezeichnet man als Referenz oder als Verweis. Und diese Referenzvariablen möchte ich dir jetzt einmal vorstellen. Doch bevor wir loslegen, lass mich noch ein paar Dinge loswerden. 🙂 Ich habe es ja schon einmal in einem früheren Beitrag erwähnt. Java unterscheidet zwischen primitiven und […]

Ein Java Fenster erzeugen mit dem JFrame

Java-Fenster-erzeugen

Ein Java Fenster erzeugen mit Swing. Java Swing – was ist das? Zum Erstellen von grafischen Benutzeroberflächen, kurz GUI, bietet Java eine eigene Standardklasse an. Diese Klasse nennt sich Swing. Aus dieser Swing-Klasse heraus können Objekte erstellt werden. Diese Objekte lassen sich in vier verschiedene Kategorien einteilen. Fenster und Dialoge bilden das Grundgerüst einer grafischen […]