Java/Schleife: Unterschied zwischen den Versionen

Aus ZUM-Unterrichten
main>Matthias Scharwies
Keine Bearbeitungszusammenfassung
K (- ZUM2Edutags)
Markierung: 2017-Quelltext-Bearbeitung
 
(8 dazwischenliegende Versionen von 3 Benutzern werden nicht angezeigt)
Zeile 1: Zeile 1:
== Aufgabenstellung ==
{{Fortsetzung|
vorher=Algorithmik<br>Logische Operatoren|vorherlink=Java/Algorithmik|
weiter=Funktionsplotter mit Turtle Grafik|weiterlink=Java/Turtle-Grafik|
übersicht=Einstieg in Java<br>(Übersicht)|übersichtlink=Java#Übersicht|}}
 
__TOC__
 
== for-Schleife ==


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:
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:
Zeile 15: Zeile 22:
</source>
</source>


== Lösung mit while-Schleife ==
Für genau diesen Fall gibt es aber auch eine Schleife: die for-Schleife.<br>
 
Sie ist immer dann sinnvoll einsetzbar,<br>
Eleganter ist da schon die Verwendung der [[java/while-Schleife|while-Schleife]]
wenn eine '''bestimmte''' Anzahl von Wiederholungen durchgeführt werden soll.
<source lang="java">
for ( int faktor = 1; faktor <= 9; faktor ++ )
{
      System.out.println("3 x " + faktor + " = " + 3*faktor );
}
</source>


=== Allgemeiner Aufbau ===
<source lang="java">
<source lang="java">
int faktor = 1;
// allgemeiner Aufbau
while ( faktor <= 9 ) {
for ( int Zählvariable mit Initialisierung; Abbruchbedingung; Inkrementierung) {
    System.out.println("3 x " + faktor + " = " + 3*faktor );
      // Anweisung, die wiederholt werden soll
    faktor++;
}
}
</source>
</source>


== Lösung mit for-Schleife ==
=== Anwendungsbeispiele ===
<source lang="java">
for ( int i = 1; i <= 10; i++ ) {}  // Hochzählen von 1 bis 10
for ( int i = 1; i <= 10; i+=5 ) {} // Hochzählen in 5er-Schritten
for ( int i = 10; i >= 1; i-- ) {}  // Countdown von 10 bis 1
</source>


Für genau diesen Fall gibt es aber auch eine Schleife: die for-Schleife. Sie ist immer dann sinnvoll einsetzbar, 
=== Aufgaben ===
* wenn eine bestimmte Anzahl von Wiederholungen durchgeführt werden soll.
{{Aufgabe|* Lassen Sie die Zahlen von 1 bis 100 auf dem Bildschirm ausgeben.
* wenn eine Variable von einem bestimmten Wert bis zu einem anderen gezählt werden soll.
** Diesmal nur die geraden Zahlen.
** Diesmal von 100 bis -100.  
* Die ungeraden Zahlen von 200 bis -1000.}}
{{Aufgabe|* Lassen Sie 50 mal den Buchstaben "A" auf den Bildschirm schreiben.
* Geben Sie alle Grossbuchstaben von A-Z durch <code>System.out.println((char)i)</code> aus.
** Informieren Sie sich dazu über die ASCII-Codierung.
** Die Ausgabe soll nun in der Form '''ASCII(87) ergibt W''' usw. erfolgen.
* Implementieren Sie die '''Caesar-Verschlüsselung''',<br> d.h. eine Verschiebung des Klartextalphabets um eine frei wählbare Zahl von Buchstaben.
** Informieren Sie sich dazu über den Modula-Operator %.}}
{{Aufgabe|* Implementieren Sie die mathematische Funktion Fakultät n!: <code>public int fakultaet(int n)</code>
*Implementieren Sie die Berechnung des Binomialkoeffizienten: <code>public int binom(int n, int k)</code>
}}


Das folgende Beispiel macht genau das selbe wie die while-Schleife im obigen Beispiel:
== 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 bei '''dynamischen''' Abbruchbedingungen, die [[#for-Schleife|for-Schleife]] hingegen bei einer festen Anzahl von Durchläufen.


=== Beispiel: Fakultät ===
Das folgende Beispiel zeigt, wie sich die Berechnung der Fakultät n! durch eine while-Schleife realisieren lässt:
<source lang="java">
<source lang="java">
for ( int faktor = 1; faktor <= 9; faktor ++ ) {
public int fakultaet(int zaehler)
      System.out.println("3 x " + faktor + " = " + 3*faktor );
{
}
    int fakultaet = 1;
    while (zaehler > 1) {
        fakultaet *= zaehler;
        zaehler--;
    }
    return fakultaet;
}
</source>
</source>


== Weitere Beispiele ==
=== Ü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:


<source lang="java">
<source lang="java">
//allgemeiner Aufbau
public class Zufallszahl
for ( Zählvariable mit Anfangswert; Anfangswert; Bedingung; Schrittweite) {
{
      // Anweisung, die wiederholt werden soll
        private int zufallszahl;
   
        // gibt eine Zufallszahl zwischen 1 und maximum zurück
        public int getZufallszahl(int maximum)
        {              
                return (int) (Math.random()*maximum+1);
        }
}
}
</source>


// hochzählen in 1er-Schritten
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).
for ( int zählvariable = Anfangswert; zählvariable <= Endwert; zählvariable++ ) {
 
      // Anweisung, die wiederholt werden soll
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).
}


// hochzählen in 5er-Schritten
<source lang="java">
for ( int zählvariable = Anfangswert; zählvariable <= Endwert; zählvariable+=5 ) {
public class Wuerfelexperiment
      // Anweisung, die wiederholt werden soll
{
}


// Countdown
    private Zufallszahl wuerfel;
for ( int zählvariable = Anfangswert; zählvariable > Endwert; zählvariable-- ) {
   
      // Anweisung, die wiederholt werden soll
    public Wuerfelexperiment (){
        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); 
        }
    }
   
}
}
</source>
</source>


== Aufgaben ==
{{Aufgabe|
#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).
#Zusätzlich soll die Summe der Würfe ausgegeben werden.
#Bestimmen Sie den Durchschnitt aller Würfe.
#Immer, wenn der vorherige Wurf gleich groß war, wie der aktuelle, soll „Gleich“ auf dem Bildschirm ausgegeben werden.
#Realisieren Sie eine Methode, die prüft, ob bei vielen Würfen jede Zahl annähernd gleich oft fällt (Kontrolle des Pseudozufallszahlgenerators).}}


{{Übung|
{{Aufgabe|
* Nennen Sie Anwendungsgebiete der for-Schleife
#Legen Sie einen zweiten Würfel an und schreiben Sie wie oben gibWuerfelAus(...).
* Lassen Sie die Zahlen von 1 bis 100 auf dem Bildschirm ausgeben
#Lassen Sie immer zuerst den größeren Würfel ausgeben.
* Diesmal nur die geraden Zahlen
#Lassen Sie anzeigen, wenn ein Pasch gewürfelt wurde.
* Diesmal von 100 bis -100
#Immer, wenn der vorherige Wurf von der Summe her gleich groß war, wie der aktuelle, soll „Gleich“ auf dem Bildschirm ausgegeben werden.
* 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
}}
}}


== Linkliste ==
== 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>{{ wpde|Schleife (Programmierung)}}; 13.12.2006</ref> (meist als DO-WHILE, das entspricht ''ausführen-während'').
 
=== "Mensch ärgere dich nicht" ===
 
<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.
 
Dabei muss mindestens einmal gewürfelt werden.
 
{{Fortsetzung|
vorher=Algorithmik<br>Logische Operatoren|vorherlink=Java/Algorithmik|
weiter=Funktionsplotter mit Turtle Grafik|weiterlink=Java/Turtle-Grafik|
übersicht=Einstieg in Java<br>(Übersicht)|übersichtlink=Java#Übersicht|}}
 
== Quellen ==
<references/>
 
== 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
Zeile 87: Zeile 192:
[[Kategorie:Unterrichtsidee]]
[[Kategorie:Unterrichtsidee]]
[[kategorie:Informatik]]
[[kategorie:Informatik]]
[[Kategorie:ZUM2Edutags]]
<metakeywords>ZUM2Edutags,ZUM-Wiki,Java/for-Schleife,Java,for-Schleife,for,Schleife,Informatik,Programmierung,Programmieren</metakeywords>

Aktuelle Version vom 11. August 2021, 19:33 Uhr

for-Schleife

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");

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.

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

Allgemeiner Aufbau

// allgemeiner Aufbau
for ( int Zählvariable mit Initialisierung; Abbruchbedingung; Inkrementierung) {
      // Anweisung, die wiederholt werden soll
}

Anwendungsbeispiele

for ( int i = 1; i <= 10; i++ ) {}  // Hochzählen von 1 bis 10
for ( int i = 1; i <= 10; i+=5 ) {} // Hochzählen in 5er-Schritten
for ( int i = 10; i >= 1; i-- ) {}  // Countdown von 10 bis 1

Aufgaben

Aufgabe
  • Lassen Sie die Zahlen von 1 bis 100 auf dem Bildschirm ausgeben.
    • Diesmal nur die geraden Zahlen.
    • Diesmal von 100 bis -100.
  • Die ungeraden Zahlen von 200 bis -1000.
Aufgabe
  • Lassen Sie 50 mal den Buchstaben "A" auf den Bildschirm schreiben.
  • Geben Sie alle Grossbuchstaben von A-Z durch System.out.println((char)i) aus.
    • Informieren Sie sich dazu über die ASCII-Codierung.
    • Die Ausgabe soll nun in der Form ASCII(87) ergibt W usw. erfolgen.
  • Implementieren Sie die Caesar-Verschlüsselung,
    d.h. eine Verschiebung des Klartextalphabets um eine frei wählbare Zahl von Buchstaben.
    • Informieren Sie sich dazu über den Modula-Operator %.
Aufgabe
  • Implementieren Sie die mathematische Funktion Fakultät n!: public int fakultaet(int n)
  • Implementieren Sie die Berechnung des Binomialkoeffizienten: public int binom(int n, int k)

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 bei dynamischen Abbruchbedingungen, die for-Schleife hingegen bei einer festen Anzahl von Durchläufen.

Beispiel: Fakultät

Das folgende Beispiel zeigt, wie sich die Berechnung der Fakultät n! durch eine while-Schleife realisieren lässt:

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

Ü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 Wuerfelexperiment
{

    private Zufallszahl wuerfel;
    
    public Wuerfelexperiment (){
        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);  
        }
    }
    
}


Aufgabe
  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).


Aufgabe
  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.

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"

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

Weblinks