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 Übung 31: Speichere deine Würfe im Array

Java Übung Array Würfelspiel

In dieser Java Übung soll ein Würfelspiel simuliert werden. Lege eine Klasse namens, Würfelspiel an. Diese Klasse enthält eine statische Methode, namens würfeln(). Diese Methode erwartet einen Parameter vom Datentyp Integer, namens „anzahlWuerfe“. Diese Variable/Parameter repräsentiert die Anzahl der Würfe. Nachdem der Methode die Anzahl der Würfe übergeben wurde, soll die Methode Zufallszahlen zwischen 1 […]

So unterstützen dich Java Vererbungstabellen beim Entwurf

Java Vererbungstabellen

Bei der Java Vererbung gibt es zwei Klassenarten bzw. -stufen. Die Superklassen, welche einen allgemeinen Typen darstellen Und die spezielleren Unterklassen, welche die Superklasse um bestimmte Funktionen erweitern. Jetzt ist dieses ganze „Der-erbt-von-dem-Konzept“ mitunter sehr schwierig darzustellen. Zum Beispiel in einem Werkzeugkoffer. In einem Werkzeugkoffer befinden sich sämtliche Werkzeuge, von Säge bis Bohrmaschine. Wie machst […]

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

Drei Möglichkeiten um Java Objekte zu zerstören

Java Objekte zerstören

Java Objekte leben genau solange, wie eine Referenzvariable auf sie zeigt. Wenn dieser Zeiger nicht mehr existiert, wird dieses Objekt aufgeben. Und wenn dieses Objekt erst einmal aufgegeben wurde, dann kommt der Garbage Collector und entsorgt dieses. Aber wie kannst du nun am Sinnvollsten Objekte aufgeben? Lass es uns herausfinden.

Java Übung 27 – Auf zur Mathe-Olympiade

Java Übung Mathe Olympiade

In dieser Java Übung möchte ich mit dir ein Programm erstellen, welches ein Mathematik-Test oder eine Mathe-Olympiade simuliert. Du kennst das vielleicht noch aus der Schule. Matheolympiade- Da wurden aus allen vier Grundrechenarten, Aufgaben formuliert. Die Schüler mussten diese Aufgaben lösen. Die Lehrer kontrollierten die Lösungen. Und der Schüler, welcher die wenigsten Fehler hatte – […]

So nutzt du Methoden aus der Java String Klasse

Java Strings Methoden

In einen der letzten Beiträge haben wir darüber gesprochen, dass Java Strings – Objekte sind. Dass Strings in allen Programmen äußerst häufig vorkommen Und dass sich deshalb Referenzvariablen String-Objekte im String Pool teilen. Das Konzept hinter dem String-Pool ist die Teilung der Ressourcen. Und das bedeutet: Weniger Objekte – mehr Speicher Mehr Speicher – bessere […]

Hier sind ein paar richtig nette Features, die dich beim Java lernen unterstützen

Java lernen Eclipse

Was ist das Wichtigste beim Einstieg in ein neues Wissensgebiet? Nein, kein gutes Sachbuch oder ein besonders guter Lehrer. Es ist Spaß. Beim Java Lernen brauchst du Spaß. Es gibt Lehrer, welche ihren Stoff so vermitteln, dass Lernen Spaß bereitet. Aber die Grundvoraussetzung ist und bleibt der Spaß. Und nichts ist so spaßhemmend wie Langeweile […]

So erstellst du deine ersten Java Klassen mit Eclipse

Java Klassen sind Baupläne für Java Objekte. Und da Java eine objektorientierte Programmiersprache ist, sind Java Klassen somit ein elementarer Bestandteil. In diesem Beitrag möchte ich dir zeigen, wie du eine Java Klasse in Eclipse erstellen kannst. Ich möchte dir außerdem zeigen, was physikalisch in deinem Projekt passiert. Ganz zum Schluss zeige ich dir noch, […]

Von Java Klassen zum Java Programm – Der Programmstart

Java Klassen ausführen

In den letzten Beiträgen hast du gelernt, wie Java Klassen erstellt werden und aufgebaut sind. In diesem Beitrag geht es um den Programmstart. Ich will dir zeigen, was nötig ist, dass du ein Java Programm ausführen kannst. Und ich zeige dir außerdem, wie du eine Startklasse in einem x-beliebigen Javaprogramm anlegst. Wie auch schon zuvor, […]

So kannst du in drei einfachen Schritten Java Arrays dynamisch vergrößern

Java Arrays vergrößern

Es ist der 31.März 1727. Es ist ein Montag. Die Welt nimmt Abschied von einem sehr bedeutenden Weltveränderer. Seine Sichtweisen beeinflussen, heute noch, die Forschung und Entwicklung im Bereichen der Physik und Chemie. Ja selbst unser aller Leben – unsere Sicht auf die alltäglichen Dinge – wurden durch seine Denkstöße revolutioniert. Dieser große Vorreiter starb […]