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

Eine Java Konsoleneingabe machst du über den Scanner

Es wird Zeit für die erste Java Konsoleneingabe. Und diese Eingaben machst du über den Java Scanner. Was ist das? Der Scanner ist eine vorgefertigte Java Klasse, welche Java mit seiner API anbietet. Das heißt du musst nichts selbst erschaffen. Du musst nur wissen, wie du darauf zugreifst. Erst einmal musst du einen Scanner anlegen. […]

Polymorphie bringt Vorteile für Java Arrays

Java Polymorphie Arrays

Wenn Java Arrays, Schubladen oder Container sein sollen… Dann wäre der Gebrauch einer solchen Schublade ziemlich einseitig und festgefahren. Denn in jedes Array passen zwar mehrere Daten – aber immer nur vom gleichen Datentyp. Immer gleicher Datentyp? Also eine Schublade nur für Socken, Unterwäsche und der ganze andere Kram passt dann eben nicht hinein. Um […]

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 […]

Lassen wir Java rechnen – Die Rechenoperationen für Variablen

Java rechnen

Ich liebe Mathe. In der Biographie „Der Mann, der die Zahlen liebte“, stellt Paul Hoffmann das Mathematikgenie Paul Erdös vor. Erdös war eines der größten Genies des 20 Jahrhunderts. Er arbeitete mit zahlreichen Wissenschaftlern zusammen und verfasste durchschnittlich mehr Publikationen im Jahr, als andere Mathematiker im ganzen Leben. Da Erdös sich mit sehr vielen Theoremen […]

So verwendest du die Java Codeblöcke zur Automatisierung

Java Codeblöcke

In diesem Beitrag geht es um den Einsatz von Java Codeblöcken oder Initialisierungsblöcken. Viele Wege führen nach Rom. Oder Alle Wege führen nach Rom. Heißt es in einem alten Sprichwort. Und so ähnlich ist es bei der Java Programmierung. In diesem Beitrag möchte ich dir einen weiteren Weg vorstellen, wie du Variablen eines Java Objektes […]

Die sechs Bestandteile von Java Methoden

Java Methoden Bestandteile

Java Methoden hauchen deinem Java Programm Leben ein. Ohne eine Methode würde deine Java Klasse ein starres Konstrukt sein. Deine Objekte hätten Eigenschaften. Aber sie könnten nichts machen. Und das wäre eine trostlose Welt. Java Methoden sorgen also dafür, dass Objekte interagieren. Methoden bestehen aus bestimmten Bausteinen. Und diese Bausteine bestimmen, was die Methode darf […]

Java lernen von Kopf bis Fuß

Wenn du Java lernen möchtest, kannst du an meinem kostenlosen Java Kurs teilnehmen. Aber manch Einer hätte gern eine zweite Meinung. Und da bieten sich natürlich Java Bücher an. Eines dieser Java Bücher möchte ich dir jetzt vorstellen. Dieses Buch nennt sich „Java von Kopf bis Fuß“. Was kannst du von diesem Buch erwarten? Also […]

Java Strings landen im String Constant Pool

Java-Strings-Pool

Du kennst das. Es ist abends. Du sitzt gemütlich vor dem Fernseher. Das Smartphone bimmelt. Kein Anruf. Nein – Eine Nachricht. Du liest die Nachricht sofort und antwortest darauf. Minuten später bekommst du die nächste Nachricht. Und auch auf diese antwortest du. Im Laufe des Abends entsteht daraus eine nette kleine Konversation. Und eh du […]