≪ View Page

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision		Previous revision
programmierung:kontrollstrukturen:loops [2024/09/22 16:08] – sweprogrammierung:kontrollstrukturen:loops [2025/12/20 14:53] (current) – external edit 127.0.0.1
Line 1: Line 1:
-~~REVEAL~~+# Schleifen / Loops
  
-====== Schleifen / Loops ====== +Schleifen sind grundlegende Kontrollstrukturen in der 
-----> +Programmierung, die es ermöglichen,
-Schleifen sind grundlegende Kontrollstrukturen in der Programmierung, die es ermöglichen, +
-  * einen Codeblock **wiederholt** auszuführen,  +
-  * solange eine bestimmte **Bedingung** erfüllt ist. +
  
-Sie sind besonders nützlich, um repetitive Aufgaben zu automatisieren und den Code effizienter und kompakter zu gestalten.+- einen Codeblock **wiederholt** auszuführen, 
 +- solange eine bestimmte **Bedingung** erfüllt ist.
  
-----> +Sie sind besonders nützlich, um repetitive Aufgaben zu automatisieren 
-Es gibt verschiedene Arten von Schleifen, die in fast jeder Programmiersprache vorkommen: +und den Code effizienter und kompakter zu gestalten.
----->+
  
-  * **for-Schleife**:  +Es gibt verschiedene Arten von Schleifen, die in fast jeder 
-    * Eine Schleife, die verwendet wird, wenn die Anzahl der Wiederholungen bekannt ist +Programmiersprache vorkommen:  
-----> +- **for-Schleife**: 
-  * **while-Schleife**:  +  - Eine Schleife, die verwendet wird, wenn die Anzahl der 
-    * Sie wird verwendet, wenn die Anzahl der Wiederholungen nicht bekannt ist.  +    Wiederholungen bekannt ist
-    * Sie endet, wenn eine bestimmte Bedingung nicht mehr wahr ist.  +
-----> +
-  * **do-while-Schleife**:  +
-    * Sie ähnelt der **while-Schleife** - nur mit dem Unterschied, dass sie in jedem Fall **einmal** ausgeführt wird und erst anschließend die Bedingung geprüft wird.  +
-    * Du wirst sehen, auch dieses Verhalten ist immer wieder gefragt beim Programmieren. +
----->> +
-===== for-Schleife ===== +
-----> +
-==== Struktogramm ==== +
-{{ :programmierung:kontrollstrukturen:for_loop_struktogramm.svg }}+
  
-Hier das Symbol für ein Struktogramm: Es erinnert an ein umgefallenes L. Oben steht die Anweisung, die den Schleifenkopf ausmacht. 
-----> 
-{{ :programmierung:kontrollstrukturen:for_loop_struktogramm_raw.svg }} 
  
-Der Schenkel des L läuft so lange, wie es innerhalb der for-Schleife Anweisungen zu erledigen gibt.  +- **while-Schleife**: 
----->+  - Sie wird verwendet, wenn die Anzahl der Wiederholungen nicht bekannt 
 +    ist. 
 +  - Sie endet, wenn eine bestimmte Bedingung nicht mehr wahr ist.
  
-Eine ''for''-Loop ist eine der grundlegendsten und am häufigsten verwendeten Kontrollstrukturen in Java.\\ + 
-Sie ermöglicht es, eine Anweisung oder einen Block von Anweisungen wiederholt auszuführen, solange eine bestimmte Bedingung erfüllt ist.\\ +- **do-while-Schleife**: 
-Die Syntax einer ''for''-Loops in Java sieht folgendermaßen aus: +  - Sie ähnelt der **while-Schleife** - nur mit dem Unterschied, dass 
-----> +    sie in jedem Fall **einmal** ausgeführt wird und erst anschließend 
-<code java>+    die Bedingung geprüft wird. 
 +  - Du wirst sehen, auch dieses Verhalten ist immer wieder gefragt beim 
 +    Programmieren. 
 + 
 + 
 +## for-Schleife 
 + 
 +Eine `for`-Loop ist eine der grundlegendsten und am häufigsten 
 +verwendeten Kontrollstrukturen in Java. 
 + 
 +Sie ermöglicht es, eine Anweisung oder einen Block von Anweisungen 
 +wiederholt auszuführen, solange eine bestimmte Bedingung erfüllt ist. 
 + 
 +Die Syntax einer `for`-Loops in Java sieht folgendermaßen aus:  
 +``` java
 for (Initialisierung; Bedingung; Update) { for (Initialisierung; Bedingung; Update) {
     // Codeblock, der wiederholt ausgeführt wird     // Codeblock, der wiederholt ausgeführt wird
 } }
-</code> +``` 
-----> + 
-<notes> +Du siehst an der Farbe des Wortes, dass das `for` ein 
-Du siehst an der Farbe des Wortes, dass das ''for'' ein Java-Schlüsselwort ist. +Java-Schlüsselwort ist. Es wird gefolgt von einem Block in runden 
-----> +Klammern: `(initalization; condition; update)`. Was bedeutet das? 
-Es wird gefolgt von einem Block in runden Klammern: ''(initalization; condition; update)''. Was bedeutet das?\\ </notes> + 
-----> + 
-  * **Initialisierung**: Wir brauchen eine Zählvariable, die die Anzahl der Durchläufe zählt. Meist setzten wir sie beim Start auf 0 - aber nagel mich nicht fest darauf! Es gibt auch Fälle, wo wir andere Startwerte brauchen +- **Initialisierung**: Wir brauchen eine Zählvariable, die die Anzahl 
-----> +  der Durchläufe zählt. Meist setzten wir sie beim Start auf 0 - aber 
-  * **Bedingung**: Hier legen wir fest, wie lange die Schleife ausgeführt wird. Meist haben wir eine Menge von Elementen, deren Anzahl wir kennen und dann lassen wir die Schleife solange laufen, bis auch das letzte Element behandelt wurde +  nagel mich nicht fest darauf! Es gibt auch Fälle, wo wir andere 
-----> +  Startwerte brauchen 
-  * **Update**: Die Zählvariable bekommt einen neuen Wert. Wie dieser berechnet wird, steht in diesem Block + 
----->+ 
 +- **Bedingung**: Hier legen wir fest, wie lange die Schleife ausgeführt 
 +  wird. Meist haben wir eine Menge von Elementen, deren Anzahl wir 
 +  kennen und dann lassen wir die Schleife solange laufen, bis auch das 
 +  letzte Element behandelt wurde 
 + 
 + 
 +- **Update**: Die Zählvariable bekommt einen neuen Wert. Wie dieser 
 +  berechnet wird, steht in diesem Block 
 Hier nun ein konkretes Beispiel: Hier nun ein konkretes Beispiel:
  
-<code java>+``` java
 for (int i = 0; i < 10; i++) { for (int i = 0; i < 10; i++) {
     System.out.println("Die aktuelle Zahl ist: " + i);     System.out.println("Die aktuelle Zahl ist: " + i);
 } }
-</code>+```
  
 Kannst du erkennen, was die Schleife macht? Kannst du erkennen, was die Schleife macht?
  
-  - **Initialisierung**: Wir deklarieren eine Variable ''i'' vom Datentyp ''int'' und weisen ihr den Startwert ''0'' zu. +1.  **Initialisierung**: Wir deklarieren eine Variable `i` vom Datentyp 
-  - **Bedingung**: Wir sagen, dass die Schleife so lange laufen soll, wie diese Variable ''i'' kleiner als 10 ist. Aber wieso steht das denn infrage? 0 ist doch kleiner 10!? Ja, aber die Variable ''i'' wird aufgrund des Updates immer größer! +    `int` und weisen ihr den Startwert `0` zu. 
-  - **Update**: Die Zählvariable bekommt einen neuen Wert. In diesem Fall wird durch das ''i+++'' die Variable ''i'' in jedem Durchlauf um 1 erhöht.+2.  **Bedingung**: Wir sagen, dass die Schleife so lange laufen soll, 
 +    wie diese Variable `i` kleiner als 10 ist. Aber wieso steht das denn 
 +    infrage? 0 ist doch kleiner 10!? Ja, aber die Variable `i` wird 
 +    aufgrund des Updates immer größer! 
 +3.  **Update**: Die Zählvariable bekommt einen neuen Wert. In diesem 
 +    Fall wird durch das `i+++` die Variable `i` in jedem Durchlauf um 1 
 +    erhöht.
  
----->> +### Deklaration und Initalisierung außerhalb des Schleifenkopfes 
-===== while-Schleife ===== +Nicht immer wird die Zählvariable im Schleifenkopf deklariert. Stell dir ein Programm vor, wo die Anzahl der Schleifendurchläufe vom **Ergebnis einer vorherigen Berechnung abhängig** ist:
-----> +
-''while''-Loops sind wie bereits erwähnt, flexibler bei einer unbekannten Zahl von Iterationen. Das kann passieren, wenn eine Menge von Einträgen zu durchlaufen sind, wir aber nicht wissen, wie viele genau das sein werden. +
-----> +
-==== Struktogramm ====+
  
-{{ :programmierung:kontrollstrukturen:while_struktogramm.svg }} +```java 
 +int anzahlKinder = 3; 
 +int anzahlErwachsene = 12; 
 +int anzahlPersonen = anzahlKinder + anzahlErwachsene; 
 +for (; anzahlPersonen < 10; anzahlPersonen++) { 
 +    System.out.println(anzahlPersonen); 
 +} 
 +``` 
 +**Hier wird im Schleifenkopf ganz darauf verzichtet, eine Zählvariable zu deklarieren und initalisieren.   
 +Es wird einfach die Variable `anzahlPersonen` verwendet, die außerhalb der Schleife deklariert und berechnet wurde.**
  
-Das Struktogramm der ''while''-Loop sieht aus, wie das der ''for''-Loop - nur der Pseudocode, der drinnen steht, ist ein anderer. Anders als bei der ''for''-Loop wird diesmal nähmlich keine Zählvariable deklariert und initialisiert. Falls wir eine solche Variable haben wollen, müsste diese von außen beigesteuert werden.  +## while-Schleife
-----> +
-{{ :programmierung:kontrollstrukturen:while_anweisung.svg }}+
  
-Eine ''while''-Loop checkt vielmehr oftmals, ob bestimmte **Bedingungen** noch wahr sind, ob sich beispielsweise **Zustände** geändert haben, oder nicht. +`while`-Loops sind wie bereits erwähnt, flexibler bei einer 
 +unbekannten Zahl von Iterationen. Das kann passieren, wenn eine Menge 
 +von Einträgen zu durchlaufen sind, wir aber nicht wissen, wie viele 
 +genau das sein werden. 
  
 +Anders als bei der `for`-Loop wird diesmal nähmlich keine Zählvariable deklariert und
 +initialisiert. Falls wir eine solche Variable haben wollen, müsste diese
 +von außen beigesteuert werden. 
  
  
----->+Eine `while`-Loop checkt vielmehr oftmals, ob bestimmte **Bedingungen** 
 +noch wahr sind, ob sich beispielsweise **Zustände** geändert haben, oder 
 +nicht.
  
-<code java  [enable_line_numbers="true",highlight_lines_extra="0",enable_keyword_links="false"] >+ 
 +``` java
         Scanner scanner = new Scanner(System.in);         Scanner scanner = new Scanner(System.in);
         String input = "";         String input = "";
Line 100: Line 127:
  
         scanner.close();         scanner.close();
-</code> +``` 
-----> + 
-<code java  [enable_line_numbers="true",highlight_lines_extra="0",enable_keyword_links="false"]>+ 
 +``` java
         int i = 0; // Initialisierung der Variablen         int i = 0; // Initialisierung der Variablen
         while (i < 5) { // Bedingung prüfen         while (i < 5) { // Bedingung prüfen
Line 108: Line 136:
             i++; // Variablen aktualisieren             i++; // Variablen aktualisieren
         }         }
-</code> +```
-----> +
-===== do-while-Schleife =====+
  
  
 +## do-while-Schleife
  
 +Die **do-while**-Schleife ist eine Kontrollstruktur in Java, die sich perfekt für Situationen eignet, in denen eine Aktion **mindestens einmal** ausgeführt werden soll, bevor eine Bedingung überprüft wird.  
 +
 +**Merkmale der do-while-Schleife**
 +
 +- Der **Schleifenrumpf** wird immer **mindestens einmal** ausgeführt.
 +- Erst **nach der ersten Iteration** wird die Bedingung überprüft.
 +- Wenn die Bedingung **wahr (true)** bleibt, wird die Schleife erneut durchlaufen.
 +- Falls die Bedingung **falsch (false)** ist, endet die Schleife.
 +
 +### Syntax:
 +```java
 +do {
 +    // Code, der mindestens einmal ausgeführt wird
 +} while (Bedingung);
 +```
 +
 +
 +### Beispiel Würfelspiel
 +
 +Stell dir ein Würfelspiel vor. Es soll so lange gewürfelt werden, bis eine 6 gefallen ist.
 +
 +Das ist der klassische Use-Case für eine `do-while`: 
 +- Mindestens einmal muss eine Aktion ausgeführt werden (gewürfelt)
 +- **Danach** wird die Aktion ausgewertet (wurde eine 6 gewürfelt)
 +
 +```java
 +import java.util.Random;
 +
 +public class WuerfelSpiel {
 +    public static void main(String[] args) {
 +        Random random = new Random();
 +        int wurf;
 +
 +        System.out.println("Würfel wird geworfen...");
 +
 +        do {
 +            wurf = random.nextInt(6) + 1; // Zufallszahl zwischen 1 und 6
 +            System.out.println("Geworfen: " + wurf);
 +        } while (wurf != 6);
 +
 +        System.out.println("Eine 6 wurde geworfen! Spiel beendet.");
 +    }
 +}
 +```