So funktioniert die Do while Schleife im Java Programm
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.
Inhalt
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.
- Die „note“ ist die, durch den Benutzer, eingebene Note.
- Die Summe aller Noten wird in der Variablen „summeNote“ gespeichert.
- Außerdem gibt es eine Variable, welche die angebene Anzahl an Noten speichert – „noteAnzahl“.
- 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();
}
}
- Starte einmal das Programm.
- Gib ein paar Noten ein.
- 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.
Über den Autor
