Skip to main content

Sicherer Schleifendurchlauf mit Do while Schleife

Es ist doch eigentlich so:
Immer wenn du die Anzahl der Schleifendurchläufe nicht kennst, nutzt du in deinen Java Programmen while Schleifen.

Doch Java bietet dir neben der While Schleife einen weiteren Schleifentyp an.
Diese nennt sich do while Schleife.

Was kann die?
Eigentlich genau das Gleiche, wie die while Schleife.
Mit einem kleinen aber sehr wichtigen Unterschied.

Die Do while Schleife führt auf jeden Fall einen Durchlauf durch.

Schau dir einmal diesen Java Code an.


public class DoWhileSchleifeDemo {
	
	static void AddiereEins(int summand){
		while (summand<=10){
			System.out.println(summand);
			summand++;
		}
	}

	public static void main(String[] args) {
		AddiereEins(1); //10 Durchläufe
		AddiereEins(11); //kein Durchlauf
	}
}

In diesem Beispiel soll die Methode eine Zahl um jeweils 1 erhöhen.
Und zwar soll das Ganze so lange gemacht werden, bis die Zahl 10 erreicht ist.

Wenn du jetzt diese Methode mit dem Argument 1 aufrufst, wird die while-Schleife 10-mal durchlaufen.
Wenn du allerdings der Methode eine 11 mitgibst, dann findet nicht ein einziger Schleifendurchlauf statt.

Und das ist mitunter etwas blöd.

Das Problem mit dem Startwert und der Schleifenbedingung.

Stell dir vor:
Du hast eine Schleife, welche Zahlen erwartet und diese analysiert.
Genau gesagt. Die Schleife nimmt Schulnoten entgegen.

Nun ist das Programm so konstruiert worden, dass es bei einer Eingabe von 0 abbricht und den Durchschnitt aller Schulnoten ausspuckt.

Du kannst somit:

  • Schön nacheinander Schulnoten eingeben
  • und nach der letzten Note gibst du nur noch eine Null ein.
  • Die Schleife bricht dadurch ab und gibt dir den Durchschnitt aller Noten zurück.

So könnte dieses Programm aussehen:


import java.util.Scanner;

public class DoWhileSchleifeDemo {
	
	static void errechneNotenDurchschnitt(){
		double durchschnitt=0; //Startwert 0 für den Durchschnitt
		Scanner eingabe=new Scanner(System.in);//Scanner-Objekt
		int note = 0;//Note mit Startwert 0
		
		int summeNote=0; //Summe aller Noten für den Durchschnitt
		int noteAnzahl =0;//Gesamtanzahl der Noten startet bei Null
		
		while(note!=0){
			System.out.println("Gib Note ein");//neue Aufforderung
			note = eingabe.nextInt();//Speichern der eingebenen Note
			noteAnzahl++;//Notenanzahl erhöht sich um jeweils 1
			summeNote=note+summeNote;//Summe der Note erhöht sich um die neue Note
		}
		durchschnitt=(double) summeNote/(double)noteAnzahl;//Ausrechnen des Durchschnittes
		System.out.println("Der Durchschnitt beträgt "+durchschnitt);//Durchschnitt wird ausgegeben
	}

	public static void main(String[] args) {
		errechneNotenDurchschnitt();//Methodenaufruf		
	}
}

Probiere dieses Programm einmal aus.
Was passiert?- Nichts wird berechnet. 🙂

Ganz kurz:
Die Methode hat vier Variablen.

  1. Die „note“ ist die, durch den Benutzer, eingebene Note.
  2. Die Summe aller Noten wird in der Variablen „summeNote“ gespeichert.
  3. Außerdem gibt es eine Variable, welche die angebene Anzahl an Noten speichert – „noteAnzahl“.
  4. Und optional gibt es eine Variable, welche den Durchschnitt aller Noten speichert. (Notensumme/Notenanzahl).

Was passiert mit der Schleife?

  • Der Startwert der Variablen „note“ ist Null.
  • Die Bedingung für die Schleife ist, dass Note nicht Null ist.
    Denn dann soll die Schleife abbrechen und den Durchschnitt aller Noten ausgeben.
  • Und das ist das Dilemma – Das Programm springt somit überhaupt nicht in die Schleife.

Klar kann man diese Schleife anders gestalten.
Indem du die erste Note ausserhalb der while Schleife speicherst.
Und dann startet die Summe der Gesamtnoten nicht bei Null, sondern bei der ersten Note.
So wie hier:


import java.util.Scanner;

public class DoWhileSchleifeDemo {
	
	static void errechneNotenDurchschnitt(){
		double durchschnitt=0; 
		System.out.println("Gib Note ein"); 
		Scanner eingabe=new Scanner(System.in);
		int note = eingabe.nextInt();//Speicherung bei der ersten Note
		
		int summeNote=note; //Summe der Note beginnt bei der ersten Note
		int noteAnzahl =0;
		
		while(note!=0){
			System.out.println("Gib Note ein");
			note = eingabe.nextInt();
			noteAnzahl++;
			summeNote=note+summeNote;
		}
		durchschnitt=(double) summeNote/(double)noteAnzahl;
		System.out.println("Der Durchschnitt beträgt "+durchschnitt);
	}

	public static void main(String[] args) {
		errechneNotenDurchschnitt();		
	}
}
  1. Starte einmal das Programm.
  2. Gib ein paar Noten ein.
  3. Und beende die Schleife durch Eingabe der Note Null.

Und läuft?

Okay, ein Problem bleibt.
Und zwar hast du doppelten Code.

Das Problem mit doppelten Code.

Hier nochmal das Programm mit dem Hinweis auf doppelten Code.


import java.util.Scanner;

public class DoWhileSchleifeDemo {
	
	static void errechneNotenDurchschnitt(){
		double durchschnitt=0; 
		System.out.println("Gib Note ein"); //Doppelter Code - siehe Schleifenrumpf
		Scanner eingabe=new Scanner(System.in);
		int note = eingabe.nextInt();//Doppelter Code -siehe  Schleifennrumpf
		
		int summeNote=note;
		int noteAnzahl =0;
		
		while(note!=0){
			System.out.println("Gib Note ein");//Doppelter Code
			note = eingabe.nextInt();//doppelter Code
			noteAnzahl++;
			summeNote=note+summeNote;
		}
		durchschnitt=(double) summeNote/(double)noteAnzahl;
		System.out.println("Der Durchschnitt beträgt "+durchschnitt);
	}

	public static void main(String[] args) {
		errechneNotenDurchschnitt();		
	}
}

Für ein kleines Projekt ist dies überschaubar.
Werden deine Projekte größer – wird es schwieriger.

Denn immer wenn du den Ablauf der Eingabe außerhalb der Schleife änderst – musst du diesen Code nochmal in der Schleife anpassen.

Was kannst du tun?
Cool wäre es doch, eine Schleife zu haben, welche für den ersten Durchlauf – die Abbruchbedingung ignoriert.


import java.util.Scanner;

public class DoWhileSchleifeDemo {
	
	static void errechneNotenDurchschnitt(){
		double durchschnitt=0;  
		Scanner eingabe=new Scanner(System.in);
		int note = 0;	
		int summeNote=0; 
		int noteAnzahl =0;
		
// bessere Schleife finden, welche den Startwert (0) der Note ignoriert
		while(note!=0){
			System.out.println("Gib Note ein");
			note = eingabe.nextInt();
			noteAnzahl++;
			summeNote=note+summeNote;
		}
		durchschnitt=(double) summeNote/(double)noteAnzahl;
		System.out.println("Der Durchschnitt beträgt "+durchschnitt);
	}

	public static void main(String[] args) {
		errechneNotenDurchschnitt();		
	}
}

Dann könntest du nämlich die erste Version des Schul-Noten-Durchschnittsprogrammes verwenden.
Diese hätte keinen doppelten Code.
Und das Programm würde einwandfrei funktionieren.

Und eine Schleife, welche die Schleifenbedingung beim ersten Durchlauf ignoriert ist: die do while Schleife.

Aufbau der Do While Schleife.

Ich wiederhole ganz kurz.
Wenn die Abbruchbedingung und der Startwert einer while-Schleife gleich sind, dann springt das Programm bzw. die Methode erst gar nicht in die Schleife.

Du brauchst in so einem speziellen Fall eine Schleife, welche immer einmal den Schleifenrumpf durchläuft und erst dann die Abbruchbedingung prüft.

Die while Schleife ist eine kopfgesteuerte Schleife.
Die Schleifenbedingung befindet sich im Schleifenkopf.
Man bezeichnet sie deshalb auch als Kopfschleife.

Die do while Schleife ist etwas anders aufgebaut.
Sie beginnt mit dem Keyword do.
Dann folgt der Schleifenrumpf mit allen Anweisungen.
Und erst dann kommt die Schleifenbedingung.

Da sich die Schleifenbedingung im Schleifenfuß befindet, ist die do-while-Schleife eine fußgesteuerte Schleife.
Oder ganz einfach Fußschleife.

Und so sieht die Schleife aus:


do {
//Rumpf mit Anweisungen
} 
while (true); //Abruchbedingung

Der Unterschied zwischen do while und while Schleife.

Lass es uns ausprobieren.

Die while Schleife und auch die do while Schleife werden solange durchlaufen, bis die Schleifenbedingung nicht mehr wahr bzw. true ist.

Wenn ich jetzt als Abbruchbedingung einer while-Schleife festlege:
Dass die Schleife solange durchlaufen werden soll, bis eine lokale Variable (zB. i) null ist.
Und ich dann dieser Variablen den Startwert Null zuweise.

Dann springt das Programm erst gar nicht in die while-Schleife.
Die do-while Schleife wird aber einmal ausgeführt und erst dann wird die Bedingung überprüft.


public class DoWhileSchleifeDemo {

	public static void main(String[] args) {
		int i = 0; //i zum Testen der Schleifen
		
		while (i != 0) {
			System.out.println("Du befindest dich in der While Schleife");
		} //Ende der while-Schleife
		
		
		do {
			System.out.println("Du befindest dich in der Do-While-Schleife.");
		}
		while (i != 0); //Ende der do-while Schleife
	}
}

Probiere es einmal aus.
Und was siehst du?
Die erste Schleife wird ignoriert.
Und die zweite wird einmal ausgeführt.

Aber da ist noch mehr….

Mit do while Schleifen lässt sich besserer Code schreiben.

Zurück zum Durchschnittsnoten-Beispiel.

Wenden wir jetzt so eine Java Do While Schleife für das Programm an.
So geht’s:


import java.util.Scanner;

public class DoWhileSchleifeDemo {
	
	static void errechneNotenDurchschnitt(){
		double durchschnitt=0; 
		Scanner eingabe=new Scanner(System.in);
		int note = 0; //Eingabe der Noten startet bei Null
		
		int summeNote=0; //Summe aller Noten startet bei Null
		int noteAnzahl =0; //Anzahl aller Noten startet bei Null
		
		do {
			System.out.println("Gib Note ein");//Einmaliger Code
			note = eingabe.nextInt();//Einmaliger Code
			noteAnzahl++;
			summeNote=note+summeNote;
		}
		while(note!=0);//Abbruchbedingung der Schleife im Rumpf
		
		durchschnitt=(double) summeNote/(double)noteAnzahl;
		System.out.println("Der Durchschnitt beträgt "+durchschnitt);
	}

	public static void main(String[] args) {
		errechneNotenDurchschnitt();		
	}
}

Alles gut?
Lass es uns checken:

  • Die Startwerte aller Variablen sind Null.
  • Die Nuller-Startwerte interessiert die Do While Schleife nicht.
    Der Schleifendurchlauf findet statt.
  • Doppelter Code wurde ebenfalls vermieden, da nur innerhalb des Rumpfes die Aufforderung zur Eingabe und die Speicherung der Variablen erfolgt.

Ein Problem bleibt.
Führe das Programm einmal aus.

  • Gib beispielsweise 2 und 3 ein.
  • Und dann beende die Schleife durch die Eingabe von Null.

Der Durchschnitt ist falsch.

Klar – denn…..

Die Zählvariable, welche im Schleifenrumpf einer Do While Schleife auftaucht, wird immer erhöht.

Ich sagte es schon:
Die Do While Schleife ist fußgesteuert.

Und das heißt:
Die Entscheidung für einen weiteren Schleifendurchlauf findet immer nachträglich statt.

Erst werden alle Anweisungen im Rumpf einmal ausgeführt und erst dann wird geprüft, ob ein weiterer Durchlauf notwendig ist.

Und für unser Beispiel bedeutet dies:
Wenn du eine Null eingibst, um die Schleife zu beenden – wird dennoch der komplette Rumpf durchlaufen.
Und somit wird auch die Zählvariable „anzahlNoten“ um eins erhöht.

Wenn du das Programm mit den Noten 2,3 und 0 testest – dann wurde die Schleife dreimal durchlaufen.
Und somit wurde die Anzahl der Noten dreimal erhöht – Es steckt dann der Wert 3 in dieser Variablen.

Was kannst du tun?
Du kannst den Startwert der Variablen „noteAnzahl“ auf -1 anstatt Null setzen.


import java.util.Scanner;

public class DoWhileSchleifeDemo {
	
	static void errechneNotenDurchschnitt(){
		double durchschnitt=0; 
		Scanner eingabe=new Scanner(System.in);
		int note = 0;
		
		int summeNote=0;
		int noteAnzahl =-1; //Anzahl aller Noten startet bei -1 
		
		do {
			System.out.println("Gib Note ein");
			note = eingabe.nextInt();
			noteAnzahl++;
			summeNote=note+summeNote;
		}
		while(note!=0);
		
		durchschnitt=(double) summeNote/(double)noteAnzahl;
		System.out.println("Der Durchschnitt beträgt "+durchschnitt);
	}

	public static void main(String[] args) {
		errechneNotenDurchschnitt();		
	}
}

Oder du belässt den Startwert bei Null.
Stattdessen ziehst du von dem ermittelten Wert eins ab.
So wie hier:


import java.util.Scanner;

public class DoWhileSchleifeDemo {
	
	static void errechneNotenDurchschnitt(){
		double durchschnitt=0; 
		Scanner eingabe=new Scanner(System.in);
		int note = 0;
		
		int summeNote=0;
		int noteAnzahl =0;//Startet bei Null
		
		do {
			System.out.println("Gib Note ein");
			note = eingabe.nextInt();
			noteAnzahl++;
			summeNote=note+summeNote;
		}
		while(note!=0);
		
		durchschnitt=(double) summeNote/(double)(noteAnzahl-1);//Anzahl wird um eins verringert
		System.out.println("Der Durchschnitt beträgt "+durchschnitt);
	}

	public static void main(String[] args) {
		errechneNotenDurchschnitt();		
	}
}

Oder eleganter ist es:
Du arbeitest mit zusätzlichen Blöcken und Verzweigungen im Do-Block.

Also lass uns dies tun. 🙂

So kannst du den Do Block um weitere Verzweigungen ergänzen.

Ziel ist es die Nuller-Eingabe abzufangen.
Und nur dann, wenn die Eingabe nicht Null ist, die Anzahl zu erhöhen.

Es ist eigentlich ganz einfach:
Platziere im Do-Block eine if-Struktur und fange mit dieser die Nuller-Eingabe ab.

Und so geht’s.


import java.util.Scanner;

public class DoWhileSchleifeDemo {
	
	static void errechneNotenDurchschnitt(){
		double durchschnitt=0; 
		Scanner eingabe=new Scanner(System.in);
		int note = 0; //Eingabe der Noten startet bei Null
		
		int summeNote=0; //Summe aller Noten startet bei Null
		int noteAnzahl =0; //Anzahl aller Noten startet bei Null
		
		do {
			System.out.println("Gib Note ein");
			note = eingabe.nextInt();
			
			//If Struktur fängt Nuller-Werte ab
			if (note !=0){
			noteAnzahl++;
			}//Ende des if-Blockes
			
			summeNote=note+summeNote;
			
		}//Ende des Do-Blockes
		while(note!=0);//Abbruchbedingung der Schleife im Rumpf
		
		durchschnitt=(double) summeNote/(double)noteAnzahl;
		System.out.println("Der Durchschnitt beträgt "+durchschnitt);
	}

	public static void main(String[] args) {
		errechneNotenDurchschnitt();		
	}
}

Zusammenfassung:

  • While Schleifen sind Kopfschleifen.
  • Beim Ablauf mit while-Schleifen wird zuerst die Abbruchbedingung überprüft.
    Wenn die Schleifenbedingung wahr ist, dann springt das Programm in die Schleife und führt die Anweisungen aus.
    Ansonsten ignoriert das Programm die Schleife und macht nach ihr weiter.
  • Die do while Schleife ist eine fußgesteuerte Schleife.
    Die Schleifenbedingung befindet sich daher im Fuß der Schleife.
  • Der Schleifenrumpf mit allen Anweisungen wird immer einmal durchlaufen und erst dann werden die Schleifenbedingungen geprüft.
  • Das bedeutet für dich. Wenn du in deinem Java Programm eine Struktur benötigst, welche mindestens einmal ausgeführt werden soll- dann setze das mit einer do while Schleife um.
    Ansonsten setze das Ganze mit while Schleife um.

Ähnliche Beiträge

Java Objekte leben auf dem Heap

Java-Objekte-Heap

Java hat eine interne Speicherverwaltung. Eigentlich ist es nicht nur eine. Es sind mehrere.   Uns interessieren nur zwei. Methoden und lokale Variablen werden auf dem Stack verwaltet. Und die Speicherverwaltung für Java Objekte und den Instanzvariablen findet auf dem Heap statt.   Ja wieso braucht Java eigentlich zwei Speichersysteme?   Es ist ganz einfach. […]

So kannst du mit dem StringTokenizer Java Strings zerlegen oder splitten

Java StringTokenizer Java Strings teilen zerlegen splitten

Java StringTokenizer – was ist das? Bevor ich diese Frage kläre, schiebe ich eine zweite Frage hinterher. Denn im Wort Tokenizer steckt das Wort Token. Also was ist ein Token? Hier die Definition zum Token: Ein Token ist eine bestimmte Aneinanderreihung von Zeichen. Man kann auch sagen, eine lexikalische Einheit. Das kann zum Beispiel eine […]

So kannst du ein Java Programm starten und Argumente übergeben

Um ein Java Programm starten zu können, benötigst du immer die main-Methode. Das Programm startet immer genau an dieser Stelle. Alle lokalen Variablen, welche du in der Main Methode anlegst, kannst du dann im Programm nutzen. Auch alle Methoden, welche du innerhalb des Methodenrumpfes der main-Methode aufrust, werden ausgeführt. Was ist aber vor der main-Methode. […]

Achte bei Java Methoden stets auf die Wertübergabe

Java Methoden Wertübergabe

Ich lege gleich los…. Schau dir diesen Code einmal an. Welche Zahl wird wohl auf der Bildschirmanzeige zurückgegeben? public class MethodenWertUebergabe { static int verdoppele (int i){ i=i*2; return i; } public static void main(String[] args) { int i = 2; verdoppele(i); System.out.println(i); } }

Beim Aufruf werden Java Methoden auf dem Stack gestapelt

Java Methoden gestapelt

Java Methoden werden beim Aufruf gestapelt. Und jedes Element auf dem Stapel nimmt Speicherplatz weg. Und manchmal ist es so, dass der Stapel richtig hoch wird und dann…. Ja was passiert eigentlich dann? Betrachten wir einmal ein Computerspiel. Irgendeines. In diesem Computerspiel gibt es Vögel, welche abgeschossen werden sollen. Was bedeutet das denn genau? Beim […]

Java Übung: Alles beginnt mit Hello World

Java Übung Hello World

Alles beginnt mit „Hello World“. Sämtliche Java Bücher beginnen mit diesem ersten Beispiel. Auch die Java Übungen sollen mit diesem ersten Programm starten. Definiere eine Klasse „Hello World“. Implementiere die Main Methode. Die Main Methode soll bei Programmaufruf die Bildschirmanzeige „Hallo Welt“ zurückgeben. Die Lösung zur Java Übung „Hallo Welt“ public class HelloWorld{ public static […]

So kannst du gelöschte Java Projekte oder Dateien in Eclipse wieder herstellen

Wahrscheinlich passiert es jedem einmal, dass man versehentlich Dateien löscht. Und dann? Die Wut ist riesig, weil man ja alles nochmal schreiben muss. In Eclipse hast du die Möglichkeit sämtliche Dateien wieder herzustellen. In diesem Beitrag möchte ich dir demonstrieren, wie du gelöschte Java Klassen, Dateien, Projekte oder Packages wieder herstellen kannst.

Der wichtige Unterschied zwischen Java Methoden

Java Methoden Unterschied

Jetzt machen wir Nägel mit Köpfen. Dieses Sprichwort stammt aus den Anfängen des Industriezeitalters. Denn früher wurden Nägel nicht industriell, sondern per Hand gefertigt. Und da kam es schon einmal vor, dass versehentlich Nägel ohne Kopf produziert wurden. Was blieb ist das Sprichwort „Nägel mit Köpfen“ Und dieses steht sinngemäß für eine schnelle, qualitativ hochwertige […]

Java Polymorphie – besserer Code und mehr Möglichkeiten

Java Polymorphie Vorteile

Polymorphie ist das Herzstück jeder objektorientierten Sprache. Nicht nur in Java – auch in Python, Javascript und in anderen Sprachen. Aber was bedeutet Polymorphie eigentlich? Polymorphie oder auch Polymorphismus genannt, kommt aus dem Griechischen. Es bedeutet Vielgestaltigkeit. Etwas freier übersetzt, kannst du es auch als Facettenreichtum bezeichnen. Im Grunde genommen zielt die ganze Java Vererbung […]