Java lernen durch Ausprobieren!

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Zuletzt angesehen:
einstieg:geschachtelt:start

Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

Link zu dieser Vergleichsansicht

Beide Seiten der vorigen RevisionVorhergehende Überarbeitung
Nächste Überarbeitung		Vorhergehende Überarbeitung
Nächste ÜberarbeitungBeide Seiten der Revision
einstieg:geschachtelt:start [2020/06/26 09:40] – Martin Pabsteinstieg:geschachtelt:start [2020/12/01 09:27] – [Beispiel 1: Einmaleinstabelle] Martin Pabst
Zeile 1: Zeile 1:
-====== Ineinandergeschachtelte Schleifen ======+====== Ineinandergeschachtelte Wiederholungen ("Schleifen"/"Loops") ======
  
-Es kommt häufig vor, dass ein Programmteil wiederholt werden muss, in dem selbst schon eine Schleife steckt. Das ist kein Problem, denn Schleifen kann man beliebig ineinander schachteln. Wofür das gut ist und wie es geht, zeige ich Dir am besten an ein paar Beispielen.+Es kommt häufig vor, dass ein Programmteil wiederholt werden muss, in dem selbst schon eine Wiederholung steckt. Wofür das gut ist und wie es geht, zeige ich Dir am besten an ein paar Beispielen.
  
 ===== Beispiel 1: Einmaleinstabelle ===== ===== Beispiel 1: Einmaleinstabelle =====
Zeile 116: Zeile 116:
 <WRAP center round todo 80%> <WRAP center round todo 80%>
 **War's das schon?** \\ \\ **War's das schon?** \\ \\
-Eigentlich ist die Aufgabe jetzt schon gelöst: Die Einmaleinstabelle wird korrekt ausgegeben. Trotzdem hoffe ich, dass Ihr mit der gefundenen Lösung genauso unzufrieden seid wie ich:+Eigentlich ist die Aufgabe jetzt schon gelöst: Die Einmaleinstabelle wird korrekt ausgegeben. Trotzdem hoffe ich, dass Ihr mit der gefundenen Lösung **genauso unzufrieden seid wie ich**:
   * Der Code ist hochgradig **[[https://de.wikipedia.org/wiki/Redundanz_(Kommunikationstheorie)|redundant]]**.    * Der Code ist hochgradig **[[https://de.wikipedia.org/wiki/Redundanz_(Kommunikationstheorie)|redundant]]**. 
-  * Wenn wir später in der for-Schleife etwas ändern wollen (z.B. weil wir einen Fehler entdeckt haben), dann müssen wir es **10-Mal ausbessern**.+  * Wenn wir später in der for-loop etwas ändern wollen (z.B. weil wir einen Fehler entdeckt haben), dann müssen wir es **10-Mal ausbessern**.
   * Das Programm **belegt sehr viel Speicherplatz**.    * Das Programm **belegt sehr viel Speicherplatz**. 
  \\ \\   \\ \\ 
Zeile 124: Zeile 124:
 </WRAP> </WRAP>
  
-== Bessere Lösung: zwei ineinandergeschachtelte Schleifen ==+==== Bessere Lösung: zwei ineinandergeschachtelte for-loops ====
 <HTML> <HTML>
  
Zeile 147: Zeile 147:
 </WRAP> </WRAP>
  
- +<WRAP center round todo 60%> 
- +Die Tabelle sieht noch nicht perfekt aus, weil die Zahlen unterschiedlich breit sind: 
- +<code> 
- +1 2 3 4 5 6 7 8 9 10 ​ 
- +2 4 6 8 10 12 14 16 18 20 
-Schalte rechts auf den "Variablen"-Tab und führe dann das Programm in Einzelschritten aus ("Step over": {{:klassen1:anwenden:step_over.png?nolink|}}). Beobachte genau den Wert der Variable ''n''! +3 6 9 12 15 18 21 24 27 30 
- +4 8 12 16 20 24 28 32 36 40 
-== Erklärung der einzelnen Anweisungen == +5 10 15 20 25 30 35 40 45 50 
-<code learnj [enable_line_numbers="true", start_line_numbers_at="1"]> +6 12 18 24 30 36 42 48 54 60 
-int n = 1;+7 14 21 28 35 42 49 56 63 70 
 +8 16 24 32 40 48 56 64 72 80 
 +9 18 27 36 45 54 63 72 81 90 
 +10 20 30 40 50 60 70 80 90 100
 </code> </code>
-Die Variable ''n'' benutzen wir, um zu zählen, wie oft wir schon wiederholt haben. ''n == 1'' bedeutet, dass wir im 1. Wiederholungsdurchgang sind. +Im Kapitel zur Wenn-Dann-Anweisung werden wir [[wenndann:if:start#beispiel_2verbesserung_der_einmaleinstabelle|das Programm noch verbessern.]] 
-<code learnj [enable_line_numbers="true", start_line_numbers_at="3"]> +</WRAP>
-while(n <= 10){ +
-   println("Hallo Welt!"); +
-   n = n + 1; +
-} +
-</code> +
-Die Anweisung ''while(n <= 10)'' bedeutet: Wiederhole die Anweisungen zwischen den nachfolgenden ''{}'', solange ''n'' kleiner oder gleich ''10'' ist. Damit die Anweisungen nicht unendlich oft wiederholt werden, müssen wir dafür sorgen, dass die Aussage ''n <= 10'' irgendwann nicht mehr zutrifft. Deshalb erhöhen wir am Ende der Schleife ''n'' um ''1'', indem wir schreiben: ''n = n + 1;''. +
-<code learnj [enable_line_numbers="true", start_line_numbers_at="10"]> +
-println("Fertig!", Color.green); +
-</code> +
-Sobald die Bedingung hinter ''while'' nicht mehr zutrifft, werden die Anweisungen in ''{}'' übersprungen und der Computer fährt mit den Anweisungen fort, die hinter den ''{}'' stehen. In diesem Fall gibt er "Fertig!" aus.+
  
  
- +===== Beispiel 2: Stern-Dreieck ===== 
-<WRAP center round info 60%> +Bisher können wir zwar nur Zeichen auf dem Bildschirm ausgeben (Computergrafik und Spieleprogrammierung kommt auch noch, versprochen!), damit lassen sich aber auch richtig schöne Bilder zeichnen [[https://www.asciiart.eu/|(Stichwort "ASCII-Art", siehe hier)]]. Wir beginnen mit einem einfachen Dreieck. 
-Mit Hilfe der ''while''-Schleife können wir eine Sequenz von Anweisungen öfters wiederholen lassen. +<code> 
-<code learnj> +*​ 
-while(Bedingung){ +**​ 
-   //Anweisungen +***​ 
-}+****​ 
 +***** 
 +****** 
 +******* 
 +******** 
 +********* 
 +********** 
 +***********​ 
 +************
 </code> </code>
-Die Anweisungen werden wiederholt, solange die Bedingung zutrifft, also den Wert ''true'' hat. \\ \\  
-**Beachte:** 
-Schon vor der Ersten Ausführung der Anweisungen wird überprüft, ob die Bedingung zutrifft. Hat sie schon zu Beginn den Wert ''false'', so werden die Anweisungen in den ''{}'' gar nicht ausgeführt.  
-</WRAP> 
-== Kleine Aufgabe == 
-Ändere das Programm oben so ab, dass es 8-mal Deinen Namen in Deiner Lieblingsfarbe ausgibt! 
  
-===== Beispiel 2: Varianten... ===== 
-Eine Schleife kann nicht nur immer wieder exakt dasselbe wiederholen. Man kann beispielsweise die Zählvariable in der Schleife benutzen, um auszugeben, wie oft die Schleife schon durchlaufen wurde: 
 <HTML> <HTML>
-<div class="java-online" style="height: 300px; width: 100%" data-java-online="{'withBottomPanel': false, 'id': 'Wiederholung3'}"> 
-<script type="text/plain" title="Main.java"> 
-int z = 1; 
  
-while(z <= 12){ +<div class="java-online" style="height: 250px; width: 100%" data-java-online="{'withBottomPanel': false, 'id': 'Schachteln1'}">
- +
-   print("Das ist der "); +
-   print(z); +
-   println("-te Wiederholungsschritt."); +
-   z++;  // z wird um 1 erhöht+
  
 +<script type="text/plain" title="Main.java">
 +for(int reihe = 1; reihe <= 12; reihe++){
 +   for(int spalte = 1; spalte <= reihe; spalte++){
 +      print("*");
 +   }
 +   println();
 } }
 </script> </script>
Zeile 207: Zeile 198:
 </HTML> </HTML>
  
-Die drei ''print''-Anweisungen kann man übrigens auch zu einer einzigen Anweisung zusammenfassen: +===== Aufgaben zum Stern-Dreieck: ===== 
-<code learnj> +1. Ändere das Programm so ab, dass die Pyramide auf dem Kopf steht, also so: 
-   println("Das ist der " + z + "-te Wiederholungsschritt");+<code> 
 +************​ 
 +***********​ 
 +********** 
 +********* 
 +******** 
 +******* 
 +****** 
 +***** 
 +**** 
 +*** 
 +** 
 +*
 </code> </code>
  
-<WRAP center round tip 60%> +[[.loesungen:aufgabe1:start|Hier geht's zur Lösung!]]
-**Addieren von Zeichenketten** \\ \\  +
-In Java bewirkt der Operator ''+'' bei Zeichenketten, dass sie hintereinandergehängt ("konkateniert") werden. Der Term ''"Das ist " + "Text"'' hat daher den Wert ''"Das ist Text"''. \\ \\  +
-Wird eine Variable vom Datentyp ''int'' zu einer Zeichenkette addiert, so wird die Variable zuerst in eine Zeichenkette umgewandelt und anschließend werden die beiden Zeichenketten hintereinandergehängt.  +
-<code learnj> +
-int z = 12; +
-println("Das ist die Zahl " + z); +
-</code> +
-gibt also aus: Das ist die Zahl 12. +
-</WRAP>+
  
-===== Beispiel 3: Quadratzahlen ===== + \\  
-Oft ist es nützlich, noch zusätzliche Variablen zu deklarieren, die bei jedem Wiederholungsschritt geändert werden. Wir schreiben ein Programm, das die ersten 10 Zweierpotenzen ausgibt, also $2^0 = 1$, $2^1 = 2$, $2^2 = 4$, $2^3 = 8$ usw. +2. Ändere das Programm so ab, dass die Pyramide zentriert erscheint, also so: 
-<HTML> +<code> 
-<div class="java-online" style="height: 300px; width: 100%" data-java-online="{'withBottomPanel': false, 'id': 'Wiederholung4'}"> +      * 
-<script type="text/plain" title="Main.java"> +     *** 
-int i = 0; +    ***** 
-int zp = 1; +   ******* 
- +  ********* 
-while(i <= 10){ + ***********
- +
-   println("2 ^ " + i + " = " + zp); +
-   i++;            // i wird um 1 erhöht +
-   zp *= 2;        // Kurzform für zp = zp * 2; +
- +
-} +
-</script> +
-</div> +
- +
-</HTML> +
- +
-Schalte rechts auf den "Variablen"-Tab und führe dann das Programm in Einzelschritten aus ("Step over": {{:klassen1:anwenden:step_over.png?nolink|}}). Beobachte genau den Wert der Variablen ''i'' und ''zp''! +
- +
-<WRAP center round tip 60%> +
-{{ :einstieg:pasted:20200620-170019.png}} +
-Wenn das Programm pausiert (etwa nach Klick auf den Pause-Button oder bei der Ausführung in Einzelschritten) kannst Du den Wert von Variablen sehen, indem Du im Programmtext mit der Maus auf die Variable fährst und etwas wartest. Es öffnet sich ein Tooltip mit dem Wert der Variable (siehe Bild rechts). +
-</WRAP> +
- +
-===== Aufgaben zur while-Schleife ===== +
- +
-Jetzt bis Du dran. [[.aufgabenwhile:start|Hier findest Du vier Aufgaben zur while-Schleife mit ansteigendem Schwierigkeitsgrad. Los geht's!]] +
- +
- +
-====== B. Die while-Schleife mit Endbedingung ====== +
-Man kann die ''while''-Schleife auch so schreiben, dass die Bedingung zum Fortfahren der Schleife jeweils erst am Ende jedes Wiederholungsschrittes überprüft wird. +
- +
-===== Beispiel 5: while-Schleife mit Endbedingung (do...while-Schleife) ===== +
-Wir zählen wieder von 1 bis 10: +
-<HTML> +
-<div class="java-online" style="height: 300px; width: 100%" data-java-online="{'withBottomPanel': false, 'id': 'Wiederholung5'}"> +
-<script type="text/plain" title="Main.java"> +
-int i = 0; +
- +
-do { +
- +
-   println(i); +
-   i++; +
- +
-} while (i <= 10); +
-</script> +
-</div> +
- +
-</HTML> +
- +
- +
-====== C. Die for-Schleife ====== +
-Die ''while''-Schleife hat zwei große Nachteile: +
-  * Zum bloßen Zählen ist sie sehr umständlich, da insgesamt drei Zeilen benötigt werden: +
-<code learnj> +
-int i = 0;         // Deklaration der Zählvariable +
-while(i <= 10){    // Bedingung +
-   // Anweisungen +
-   i++;            // Erhöhung der Zählvariable +
-}+
 </code> </code>
-  * Oft stehen zwischen der Deklaration der Zählvariable und der Bedingung sowie zwischen der Bedingung und der Erhöhung der Zählvariable sehr viele Anweisungen und es ist schwer, "auf einen Blick" zu erfassen, wie oft wiederholt wird und welche Werte die Zählvariable bei jedem Wiederholungsschritt annimmt.+**Tipps:** 
 +  * Jede Reihe besteht jetzt aus einer ungeraden Anzahl von Sternen. Die Variable ''reihe'' soll also nicht die Werte 1, 2, 3, ... annehmen, sondern die Werte 1, 3, 5, ... 
 +  * Vor jeder Reihe von Sternen stehen unterschiedlich viele Leerzeichen. Wie kann man die Anzahl der Leerzeichen aus der Anzahl der Sterne ( = Reihennummer) berechnen? Dazu eine Hilfstabelle:
  
-Für alle Anwendungsfälle, in denen auf irgendeine Art und Weise gezählt wird, verwendet man daher üblicherweise eine Kurzschreibweise der ''while''-Schleife, die ''for''-Schleife. Hier eine Gegenüberstellung der beiden. Beide Programme sind gleichwertig:+^ Reihe ^ Anzahl von Sternen ^ Anzahl von Leerzeichen ^ 
 +|1|1|6| 
 +|3|3|5| 
 +|5|5|7| 
 +...
  
-^ While-Schleife ^ For-Schleife ^ + \\  
-| {{:einstieg:pasted:20200620-185526.png}} | {{:einstieg:pasted:20200620-185646.png}} |+[[.pyramidezentriert:start|Hier geht's zur Lösung!]]
  
-<WRAP center round info 60%> +===== Beispiel 3: Grafik ===== 
-Die ''for''-Schleife ist eine Kurzform der ''while''-Schleife. Sie besteht aus drei Bestandteilen: \\  +Die Erzeugung von Grafikobjekten lernen wir [[klassen1:anwenden:start|erst etwas später]], trotzdem glaube ich, dass Du das folgende Beispiel bestimmt schon verstehen kannst. Nur so viel: 
-<code learnj>for(Startanweisung; Bedingung; Anweisung am Ende jedes Wiederholungsschrittes){ +<code myjava> 
-   // Anweisungen +new Circle(300, 200, 100);
-}+
 </code> </code>
-  * Die **Startanweisung** wird genau 1-mal zu Beginn der Schleife aufgerufen. +erzeugt ein Kreis-Objekt mit Mittelpunkt $(300,200)$ und Radius 100.
-  * Die **Bedingung** wird vor jedem Wiederholungsschritt ausgewertet. Ist ihr Wert ''true'', so werden die Anweisungen in den ''{}'' ausgeführt. Ist der Wert ''false'', so werden die Anweisungen in den ''{}'' übersprungen und es wird mit der Anweisung hinter der for-Schleife fortgefahren. +
-  * Die **Anweisung am Ende jedes Wiederholungsschrittes** wird am Ende jedes Wiederholungsschrittes ausgeführt. +
-Für Einsteiger ist die ''for''-Schleife oft schwer zu verstehen, weil ihre drei Bestandteile jeweils ganz unterschiedliche Bedeutung haben. Noch dazu ist der 1. und 3. Bestandteil eine Anweisung, der 2. Bestandteil eine Bedingung (genauer: eine Aussage). \\ \\ **Lass' Dich nicht entmutigen:** Meist wird die ''for''-Schleife zum **Zählen** benutzt und sieht so oder ähnlich aus: +
-<code learnj> +
-for(int i = 0; i < 10; i++){ +
-   // Anweisungen +
-} +
-</code> +
-Dieses Muster (das in diesem Fall die Anweisungen für ''i''-Werte von 0 bis 9 durchführt) wirst Du sehr schnell beherrschen und - von diesem Muster ausgehend - bald auch schwierigere Konstruktionen mit ''for'' verstehen. +
-</WRAP> +
- +
-Führe die folgenden Programme in Einzelschritten aus ("Step over": {{:klassen1:anwenden:step_over.png?nolink|}}), und zwar +
-  * zunächst mit offenem Tab "Ausgabe" auf der rechten Seite +
-  * dann mit offenem Tab "Variablen" auf der rechten Seite. +
-Beobachte genau, was jeder Einzelne Programmschritt bewirkt!+
  
-===== Beispiel 6: Zählen mit "for" ===== 
-Wir schreiben den Text "Hallo Welt!" 10-mal untereinander in die Ausgabe. Mit der Variablen ''i'' zählen wir dabei, wie oft wir ihn schon ausgegeben haben. 
 <HTML> <HTML>
  
-<div class="java-online" style="height: 300px; width: 100%" data-java-online="{'withBottomPanel': false, 'id': 'Wiederholung6'}">+<div class="java-online" style="height: 250px; width: 100%" data-java-online="{'withBottomPanel': false, 'id': 'Schachteln2'}">
  
 <script type="text/plain" title="Main.java"> <script type="text/plain" title="Main.java">
-for(int i = 1; i <= 10; i++){ +for(int zeile = 1; zeile <= 15; zeile++){ 
-   println("Hallo Welt (zum " + i + "-ten Mal)!");+   for(int spalte = 1; spalte <= 16 - zeile; spalte++){ 
 +      new Circle(30*spalte, 30*zeile, (spalte + zeile)*1.2); 
 +      new Circle(30*(16-spalte), 30*(16-zeile), (spalte + zeile)*1.2); 
 +   }
 } }
-println("Fertig!", Color.lightgreen); 
 </script> </script>
 </div> </div>
  
 </HTML> </HTML>
 + \\ 
  
-== Erklärung ==  
-Die ''for''-Schleife bewirkt, dass der Rechner folgendes macht: 
-^Anweisung^Erklärung^Wert von ''i'' nach der Anweisung^ 
-|''int i = 1;''|Die Startanweisung wird genau ein Mal zu Beginn ausgeführt.|1| 
-|Prüfe: Ist ''i <= 10''? |Das Ergebnis der Prüfung ist ''true'', da $1 \le 10$ ist. Daher wird als nächste die Anweisung in ''{}'' ausgeführt.|1| 
-|''println("Hallo Welt (zum " + i + "-ten Mal)!");''| Es wird ausgegeben: ''Hallo Welt (zum 1. Mal)!'' |1| 
-|''i++;''| Am Ende des Wiederholungsschrittes wird ''i++'' ausgeführt und damit der Wert von ''i'' um 1 erhöht. Der Rechner setzt die Ausführung in Zeile 1 fort.|2| 
-|Prüfe: Ist ''i <= 10''? |Das Ergebnis der Prüfung ist ''true'', da $2 \le 10$ ist. Daher wird als nächste die Anweisung in ''{}'' ausgeführt.|2| 
-|''println("Hallo Welt (zum " + i + "-ten Mal)!");''| Es wird ausgegeben: ''Hallo Welt (zum 2. Mal)!'' |2| 
-|''i++;''| Am Ende des Wiederholungsschrittes wird ''i++'' ausgeführt und damit der Wert von ''i'' um 1 erhöht. Der Rechner setzt die Ausführung in Zeile 1 fort.|3| 
  
-usw... \\ \\ Die letzten Schritte sehen so aus: 
-|''println("Hallo Welt (zum " + i + "-ten Mal)!");''| Es wird ausgegeben: ''Hallo Welt (zum 9. Mal)!'' |9| 
-|''i++;''| Am Ende des Wiederholungsschrittes wird ''i++'' ausgeführt und damit der Wert von ''i'' um 1 erhöht. Der Rechner setzt die Ausführung in Zeile 1 fort.|10| 
-|Prüfe: Ist ''i <= 10''? |Das Ergebnis der Prüfung ist ''true'', da $10 \le 10$ ist. Daher wird als nächste die Anweisung in ''{}'' ausgeführt.|10| 
-|''println("Hallo Welt (zum " + i + "-ten Mal)!");''| Es wird ausgegeben: ''Hallo Welt (zum 10. Mal)!'' |10| 
-|''i++;''| Am Ende des Wiederholungsschrittes wird ''i++'' ausgeführt und damit der Wert von ''i'' um 1 erhöht. Der Rechner setzt die Ausführung in Zeile 1 fort.|11| 
-|Prüfe: Ist ''i <= 10''? |Das Ergebnis der Prüfung ist ''false'', da **nicht** $11 \le 10$ ist. Daher wird jetzt die Anweisung in ''{}'' übersprungen und es geht in Zeile 4 weiter!|11| 
-|''println("Fertig!", Color.lightgreen);''| | | 
  
  
-===== Beispiel 7: Zählen im Dreierschritt ===== +===== Weitere Aufgaben ===== 
- +[[.geschachteltewh:weitereaufgaben:start|Weitere Aufgaben zu geschachtelten Wiederholungen findest Du hier.]]
-<HTML> +
- +
-<div class="java-online" style="height: 300px; width: 100%" data-java-online="{'withBottomPanel': false, 'id': 'Wiederholung7'}"> +
- +
-<script type="text/plain" title="Main.java"> +
-println("Dreier-Einmaleins:", Color.lightgreen); +
-for(int n = 3; n <= 30; n += 3){ +
-   print(n + ", "); +
-} +
-println(" -> Fertig!", Color.lightgreen); +
-</script> +
-</div> +
- +
-</HTML> +
-<WRAP center round tip 60%> +
-Du erinnerst Dich sicher: ''n += 3'' ist eine Kurzschreibweise für ''n = n + 3'' und bewirkt, dass der Wert der Variable ''n'' um ''3'' erhöht wird. +
-</WRAP> +
- +
- +
-===== Beispiel 8: Berechnung von 8! ===== +
-<WRAP center round tip 80%> +
-**Berechnung von Fakultäten** \\ \\  +
-Die **Faktultät** einer Zahl $n \in \mathbb{N}$, kurz $n!$, ist folgendermaßen definiert: +
-$$n! = 1 \cdot 2 \cdot 3 \cdot 4 \cdot \ldots  \cdot n$$ +
-Es ist beispielsweise $5! = 1 \cdot 2 \cdot 3 \cdot 4 \cdot 5 = 120$. +
-</WRAP> +
- +
-<HTML> +
- +
-<div class="java-online" style="height: 300px; width: 100%" data-java-online="{'withBottomPanel': false, 'id': 'Wiederholung8'}"> +
- +
-<script type="text/plain" title="Main.java"> +
-int zahl = 8; +
-int fakultät = 1; +
- +
-for(int i = 1; i <= zahl; i++){ +
-   fakultät *= i; +
-} +
- +
-println(zahl + "! = " + fakultät); +
-</script> +
-</div> +
-</HTML> +
- +
-Probiere das Programm wieder in Einzelschritten aus und schau' Dir die Belegung der Variablen nach jedem Schritt an!  +
-  * Du kannst die ''8'' in der ersten Zeile natürlich auch durch eine andere Zahl ersetzen! +
-  * Warum wird der Variablen ''fakultät'' in Zeile 2 der Startwert ''1'' zugeordnet und nicht ''0''? \\ (Falls Du nicht auf die Antwort kommst, probier' es aus, indem Du die ''1'' im Programm durch ''0'' ersetzt!)+
einstieg/geschachtelt/start.txt · Zuletzt geändert: 2021/12/29 11:29 von 127.0.0.1
Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki