Schleife: Unterschied zwischen den Versionen

aus ZUM-Wiki, dem Wiki für Lehr- und Lerninhalte auf ZUM.de
Wechseln zu: Navigation, Suche
Zeile 27: Zeile 27:
 
</source>
 
</source>
  
== Lösung mit for-Schleife ==
+
== for-Schleife ==
  
 
Für genau diesen Fall gibt es aber auch eine Schleife: die for-Schleife. Sie ist immer dann sinnvoll einsetzbar,   
 
Für genau diesen Fall gibt es aber auch eine Schleife: die for-Schleife. Sie ist immer dann sinnvoll einsetzbar,   
Zeile 41: Zeile 41:
 
</source>
 
</source>
  
== Weitere Beispiele ==
+
=== Weitere Beispiele ===
  
 
<source lang="java">
 
<source lang="java">
Zeile 65: Zeile 65:
 
</source>
 
</source>
  
== Aufgaben ==
+
 
  
 
{{Übung|
 
{{Übung|
Zeile 127: Zeile 127:
 
</source>
 
</source>
  
===Endlosschleife===
+
=== Endlosschleife ===
  
 
Eine Schleife, die (eigentlich) niemals endet und dabei den Computer völlig auslastet ist eine typische Ursache für Abstürze.
 
Eine Schleife, die (eigentlich) niemals endet und dabei den Computer völlig auslastet ist eine typische Ursache für Abstürze.
Zeile 147: Zeile 147:
 
Bevor Sie die Methode ausprobieren, lesen Sie zunächst, wie man in [[BlueJ]] Programmausführungen stoppt:
 
Bevor Sie die Methode ausprobieren, lesen Sie zunächst, wie man in [[BlueJ]] Programmausführungen stoppt:
  
====Notunterbrechungen bei BlueJ====
+
==== Notunterbrechungen bei BlueJ ====
  
 
Mit Strg+Umschalt+R setzen Sie die Virtuelle Maschine zurück, was eine Beendigung der aktuell ausgeührten Methode bewirkt. Sie können auch auf der rot-weißen Ausführungsnanzeige mit der rechten Maustaste das Kontextmenu hervorholen und die Ausführung damit stoppen.
 
Mit Strg+Umschalt+R setzen Sie die Virtuelle Maschine zurück, was eine Beendigung der aktuell ausgeührten Methode bewirkt. Sie können auch auf der rot-weißen Ausführungsnanzeige mit der rechten Maustaste das Kontextmenu hervorholen und die Ausführung damit stoppen.
Zeile 162: Zeile 162:
 
}}
 
}}
  
==Übungen mit while und Zufallszahlen==
+
=== Übungen mit while und Zufallszahlen ===
  
 
Übungen zu Zufallszahlen eignen sich, um die Interaktion zwischen verschiedenen Klassen zu demonstrieren. Die recht einfache Klasse Zufallszahl sieht wie folgt aus:
 
Übungen zu Zufallszahlen eignen sich, um die Interaktion zwischen verschiedenen Klassen zu demonstrieren. Die recht einfache Klasse Zufallszahl sieht wie folgt aus:
Zeile 235: Zeile 235:
 
}}
 
}}
  
==Fakultät==
+
=== Fakultät ===
 
Das folgende Beispiel zeigt, wie sich die while-Schleife zur Berechnung der Fakultät einsetzen kann. Denkbar wäre auch ein Einsatz der for-Schleife.  
 
Das folgende Beispiel zeigt, wie sich die while-Schleife zur Berechnung der Fakultät einsetzen kann. Denkbar wäre auch ein Einsatz der for-Schleife.  
 
<source lang="java">
 
<source lang="java">
Zeile 249: Zeile 249:
 
</source>
 
</source>
  
 +
== do-while-Schleife ==
 +
Eine '''do-while-Schleife''' ist in der Programmierung eine „''fußgesteuerte'' oder ''nachprüfende'' Schleife, bei der nach dem Durchlauf des Schleifenrumpfes die Abbruchbedingung überprüft wird“<ref>{{ wpd|Schleife (Programmierung)}}; 13.12.2006</ref> (meist als DO-WHILE, das entspricht ''ausführen-während'').
 +
 +
=== "Mensch ärgere dich nicht"-Spiel ===
 +
 +
<source lang="java">
 +
int wuerfel;
 +
do {
 +
  wuerfel=(int) (Math.random()*6+1);
 +
} while (wuerfel!=6);
 +
</source>
 +
 +
dh. würfele solange, bis eine 6 gefallen ist, bzw. andersherum: wiederhole das Würfeln solange, solange das Würfelergebnis nicht 6 ist.
  
[[Kategorie:Java]]
+
Dabei muss mindestens einmal gewürfelt werden.
[[Kategorie:Unterrichtsideen/Informatik]]
+
<metakeywords>ZUM2Edutags,ZUM-Wiki,Java/while-Schleife,Java,while-Schleife,while,Schleife,Informatik,Programmierung,Programmieren</metakeywords>[[Kategorie:ZUM2Edutags]]
+
  
 +
== Quellen ==
 +
<references/>
  
== Linkliste ==
+
== Weblinks ==
  
 +
* {{wpde|Schleife (Programmierung)}}
 +
* {{wpde|Bubblesort#Java}} - Bubblesort mit do-while-Schleife
 
* wikibooks: [https://de.wikibooks.org/wiki/Kurzeinstieg_Java:_Kontrollstrukturen Kurzeinstieg Java: Kontrollstrukturen]  
 
* wikibooks: [https://de.wikibooks.org/wiki/Kurzeinstieg_Java:_Kontrollstrukturen Kurzeinstieg Java: Kontrollstrukturen]  
 
* http://www.programmersbase.net/Content/Java/Content/Tutorial/Java/Loop.htm
 
* http://www.programmersbase.net/Content/Java/Content/Tutorial/Java/Loop.htm

Version vom 19. August 2019, 11:31 Uhr

Inhaltsverzeichnis

Aufgabenstellung

Häufig benötigt man beim Programmieren eine mehrfache Ausführung eines Teilbereichs. Denkbar ist, dass ein Programmierer dazu einfach Zeilen wiederholt. So lässt sich z.B. das kleine 1 x 1 von 3 wie folgt ausgeben:

System.out.println("3 x 1 = 3");
System.out.println("3 x 2 = 6");
System.out.println("3 x 3 = 9");
System.out.println("3 x 4 = 12");
System.out.println("3 x 5 = 15");
System.out.println("3 x 6 = 18");
System.out.println("3 x 7 = 21");
System.out.println("3 x 8 = 24");
System.out.println("3 x 9 = 27");

Lösung mit while-Schleife

Eleganter ist da schon die Verwendung der while-Schleife

int faktor = 1;
while ( faktor <= 9 ) {
    System.out.println("3 x " + faktor + " = " + 3*faktor );
    faktor++;
}

for-Schleife

Für genau diesen Fall gibt es aber auch eine Schleife: die for-Schleife. Sie ist immer dann sinnvoll einsetzbar,

  • wenn eine bestimmte Anzahl von Wiederholungen durchgeführt werden soll.
  • wenn eine Variable von einem bestimmten Wert bis zu einem anderen gezählt werden soll.

Das folgende Beispiel macht genau das selbe wie die while-Schleife im obigen Beispiel:

for ( int faktor = 1; faktor <= 9; faktor ++ ) {
      System.out.println("3 x " + faktor + " = " + 3*faktor );
}

Weitere Beispiele

//allgemeiner Aufbau
for ( Zählvariable mit Anfangswert; Anfangswert; Bedingung; Schrittweite) {
      // Anweisung, die wiederholt werden soll
}
 
// hochzählen in 1er-Schritten
for ( int zählvariable = Anfangswert; zählvariable <= Endwert; zählvariable++ ) {
      // Anweisung, die wiederholt werden soll
}
 
// hochzählen in 5er-Schritten
for ( int zählvariable = Anfangswert; zählvariable <= Endwert; zählvariable+=5 ) {
      // Anweisung, die wiederholt werden soll
}
 
// Countdown
for ( int zählvariable = Anfangswert; zählvariable > Endwert; zählvariable-- ) {
      // Anweisung, die wiederholt werden soll
}


Hand.gif   Übung
  • Nennen Sie Anwendungsgebiete der for-Schleife
  • Lassen Sie die Zahlen von 1 bis 100 auf dem Bildschirm ausgeben
  • Diesmal nur die geraden Zahlen
  • Diesmal von 100 bis -100
  • Die ungeraden von 200 bis -1000
  • Lassen Sie 50 mal den Buchstaben "A" auf den Bildschirm schreiben
  • Die Zahlen von -10 bis 10 ohne die 0

while-Schleife

In den meisten Programmiersprachen gibt es die While-Schleife als Kontrollstruktur. Sie dient dazu, eine Abfolge von Anweisungen mehrfach auszuführen, solange eine Bedingung erfüllt ist. Diese Bedingung wird geprüft, bevor die Anweisungsfolge abgearbeitet wird. Es kann also auch sein, dass die Abfolge gar nicht ausgeführt wird. Wenn die Bedingung ständig erfüllt ist, dann wird die Schleife zur Endlosschleife.


Die While-Schleife verwendet man normalerweise bei dynamischen Abbruchbedingungen, die for-Schleife meistens, wenn man vorher definiert wie viele Durchläufe die Schleife hat. Zum Beispiel würde man für die Berechnung der Fakultät einer Zahl vorzugsweise die For-Schleife anwenden.

Versteckspiel

Nuvola apps edu miscellaneous.png   Unterrichtsidee

Mit Hilfe des folgenden Beispiels lässt sich die while-Schleife einführen. Besser ist allerdings, wenn man es mit einer for-Schleife realisiert. D.h. falls man es nutzt, sollte man dieses Beispiel vor der for-Schleife behandeln.

Versteckspiel
Als Suchender muss man zunächst bis 100 zählen, dann laut „Ich komme...“ rufen. Erst dann darf man zum Suchen aufbrechen.

Dieses simple Spiel ist ein einfacher Algorithmus:

VERSTECKSPIELZÄHLUNG
Die erste Zahl ist 1.
Prüfe, ob die 100 erreicht wurde
Wenn das noch nicht erfüllt ist, sage die Zahl und erhöhe die Zahl um eins.
Wenn doch, dann rufe „Ich komme“

Mit while (engl. solange) lassen sich Programmabläufe abhängig von einer Bedingung wiederholen. Die Bedingung wird vor Ausführung der Anweisung abgefragt ("prechecked loop", "kopfgesteuerte Schleife").

Solange <Bedingung erfüllt> führe <Anweisung> aus.
Java-Syntax
   while (Bedingung) 
   {
      Anweisungsblock (was soll wiederholt werden?)
   }

So sähe das Verstecken-Beispiel als Methode der Klasse Verstecken aus. Der Computer schreibt die Zahlen von 1 bis zahl in die Konsole.

Hinweis
Wenn die oberen Zahlen nicht mehr zu sehen sind, liegt das an der Konsole, die nur begrenzt viele Zeilen zulässt. Das Problem kann man umgehen, indem man statt println ein print einsetzt. Dann wird nicht bei jeder Zahl eine neue Zeile begonnen.
public class Verstecken
{
      public void zaehleBisZahlundRufe(int zahl)
      {
        int x;                            // Eine Zählvariable x
        x=1;                              // Anfangswert für x
        while (x <= zahl) {   
            System.out.println (x);       // schreibe x auf die Konsole
            x++;                          // erhöhe x um 1
        }
        System.out.println ("Ich komme...!"); 
      }
}

Endlosschleife

Eine Schleife, die (eigentlich) niemals endet und dabei den Computer völlig auslastet ist eine typische Ursache für Abstürze.

Die folgende Methode ist eine Endlosschleife, die unendlich lange ausgeführt würde, wenn niemand die Ausführung stoppen würde. Typischer Fehler: Es wird x als Bedingung abgefragt: (x<100) , aber es wird x nicht innerhalb der Schleife verändert.

    public void führeEndlosschleifeAus(){
      int x; // Eine Zählvariable x
      x=1;   // Anfangswert für x
      while (x <= 100) {   
          System.out.println (x);       // schreibe x auf die Konsole
          // Typischer Fehler: x wird in der Schleife nicht erhöht.                     
      }   
    }

Bevor Sie die Methode ausprobieren, lesen Sie zunächst, wie man in BlueJ Programmausführungen stoppt:

Notunterbrechungen bei BlueJ

Mit Strg+Umschalt+R setzen Sie die Virtuelle Maschine zurück, was eine Beendigung der aktuell ausgeührten Methode bewirkt. Sie können auch auf der rot-weißen Ausführungsnanzeige mit der rechten Maustaste das Kontextmenu hervorholen und die Ausführung damit stoppen.

Hand.gif   Übung
  1. Analysieren Sie die Methode zaehleBisZahlundRufe (int zahl), indem Sie folgende Dinge zunächst durchdenken und dann testen:
    • Was passiert, wenn Sie beim Methodenaufruf 1 als zahl übergeben.
    • Was passiert, wenn Sie beim Methodenaufruf negative Zahlen eingeben.
    • Was verändert sich, wenn die Zeile mit x++ über der System.out Zeile steht?
    • Wie können Sie in Zweierschritten zählen?
    • Warum wird „Ich komme“ nur ein mal ausgegeben?
  2. Verändern Sie die Methode so, dass ein Coutntdown heruntergezählt wird.
  3. Lassen Sie neben zahl auch die Variable schwrittweite übergeben. Sie soll bestimmen, in wie großen Schritten heraufgezählt werden soll (z.B. Schrittwete 3 ergibt: 1, 4, 7, 10...

Übungen mit while und Zufallszahlen

Übungen zu Zufallszahlen eignen sich, um die Interaktion zwischen verschiedenen Klassen zu demonstrieren. Die recht einfache Klasse Zufallszahl sieht wie folgt aus:

public class Zufallszahl
{
        private int zufallszahl;
 
        // gibt eine Zufallszahl zwischen 1 und maximum zurück
        public int getZufallszahl(int maximum)
        {               
                return (int) (Math.random()*maximum+1);
        }
}

Diese Klasse kann man nun auf einfache Weise in anderen Klassen verwenden. Eine Eigenschaft z.B. wuerfel vom Typ Zufallszahl wird vorbereitet (vgl. erste Zeilen).

Nun lassen sich mit wuerfel.getZufallszahl(6) Zufallszahlen zwischen 1 und 6 bestimmen, die man z.B. ausgeben kann (erste Methode) oder einer Variable zuweisen kann (zweite Methode).

public class Wuerfelexperiment1
{
 
    private Zufallszahl wuerfel;
 
    public Wuerfelexperiment1 (){
        wuerfel=new Zufallszahl();
    }
 
    public void gibWuerfelAus(int anzahl)
    {
        int i=1;
        while (i<=anzahl){
            System.out.println("Wurf "+i+ " ist "+wuerfel.getZufallszahl(6));
            i++;
        }
    }
 
    public void wuerfeleBisZurSechs()
    {
        int i=1;
 
        // Erster Wurf muss auf jeden Fall durchgeführt werden
        int zwischenspeicher=wuerfel.getZufallszahl(6);
        System.out.println("Wurf "+i+ " ist "+zwischenspeicher);
 
        // weitere Würfe
        while (zwischenspeicher!=6){
            i++;
            zwischenspeicher=wuerfel.getZufallszahl(6);
            System.out.println("Wurf "+i+ " ist "+zwischenspeicher);  
        }
    }
 
}
Hand.gif   Übung
  1. Der Benutzer soll bei der Methode gibWuerfelAus selbst angeben können, wie viele Seiten der Würfel hat (es gibt z.B. auch 8-seitige oder 24-seitige Würfel).
  2. Zusätzlich soll die Summe der Würfe ausgegeben werden.
  3. Bestimmen Sie den Durchschnitt aller Würfe.
  4. Immer, wenn der vorherige Wurf gleich groß war, wie der aktuelle, soll „Gleich“ auf dem Bildschirm ausgegeben werden.
  5. Realisieren Sie eine Methode, die prüft, ob bei vielen Würfen jede Zahl annähernd gleich oft fällt (Kontrolle des Pseudozufallszahlgenerators).

Würfelexperiment2 – diesmal mit 2 Würfeln

  1. Legen Sie einen zweiten Würfel an und schreiben Sie wie oben gibWuerfelAus(...).
  2. Lassen Sie immer zuerst den größeren Würfel ausgeben.
  3. Lassen Sie anzeigen, wenn ein Pasch gewürfelt wurde.
  4. Immer, wenn der vorherige Wurf von der Summe her gleich groß war, wie der aktuelle, soll „Gleich“ auf dem Bildschirm ausgegeben werden.

Fakultät

Das folgende Beispiel zeigt, wie sich die while-Schleife zur Berechnung der Fakultät einsetzen kann. Denkbar wäre auch ein Einsatz der for-Schleife.

 public int fakultaet(int zaehler)
 {
     int fakultaet=1;
     while (zaehler > 1) {
         fakultaet*=zaehler;
         zaehler--;
     }
     return fakultaet;
 }

do-while-Schleife

Eine do-while-Schleife ist in der Programmierung eine „fußgesteuerte oder nachprüfende Schleife, bei der nach dem Durchlauf des Schleifenrumpfes die Abbruchbedingung überprüft wird“[1] (meist als DO-WHILE, das entspricht ausführen-während).

"Mensch ärgere dich nicht"-Spiel

int wuerfel;
do {
  wuerfel=(int) (Math.random()*6+1);
} while (wuerfel!=6);

dh. würfele solange, bis eine 6 gefallen ist, bzw. andersherum: wiederhole das Würfeln solange, solange das Würfelergebnis nicht 6 ist.

Dabei muss mindestens einmal gewürfelt werden.

Quellen

  1. Schleife (Programmierung)Wikipedia-logo.png; 13.12.2006

Weblinks