Info

Autor: HM_JDSZielgruppe: Sek I

Schleifen und Uebungen

Dieses Kapitel basiert auf dem Arbeitsblatt "Schleifen" (EF.08). Dort werden for- und while-Schleifen nicht nur syntaktisch eingefuehrt, sondern ueber viele kleine Methodenaufgaben systematisch trainiert.

Warum Schleifen zentral sind

Viele Programmprobleme haben dieselbe Grundstruktur:

  • Eine Aktion wird mehrfach ausgefuehrt.
  • Eine Datenmenge wird vollstaendig durchlaufen.
  • Eine Bedingung steuert, wann abgebrochen wird.

Schleifen sind genau das Werkzeug fuer diese Wiederholung.

Die for-Schleife aus dem Arbeitsblatt

Allgemeine Form:

for (init; test; update) {
    // anweisungen
}

Beispiel aus dem Blattkontext:

for (int i = 1; i <= 5; i = i + 1) {
    System.out.println("Dieser Satz ist falsch! " + i);
}

Der Kopf hat drei Rollen:

  1. Initialisierung (einmalig)
  2. Bedingung (vor jedem Durchlauf)
  3. Update (nach jedem Durchlauf)

Kurzform fuer i = i + 1 ist i++.

Die while-Schleife

Im Arbeitsblatt wird betont:

  • while ist sinnvoll, wenn die Anzahl der Durchlaeufe nicht von Anfang an feststeht.
  • Endlosschleifen sind moeglich, wenn die Bedingung nie false wird.
int i = 0;
while (i < 10) {
    System.out.println(i);
    i++;
}

Eine for-Schleife kann oft als while formuliert werden. Umgekehrt ist nicht jede while-Situation elegant als for darstellbar.

Sichtbarkeit der Zaehlervariable

Das Blatt nennt einen wichtigen Unterschied:

for (int i = 0; i < 10; i++) {
    ...
}

Hier ist i ausserhalb der Schleife nicht mehr sichtbar.

Bei

int i = 0;
while (i < 10) {
    ...
    i++;
}

bleibt i danach sichtbar.

Das hat Folgen fuer Lesbarkeit und Fehlervermeidung.

Methodentraining mit Schleifen (Aufgabenblock)

Das Arbeitsblatt laesst viele kleine statische Methoden implementieren. Dadurch werden Schleifen in klaren Mini-Szenarien geuebt.

Gruppe 1: Wiederholte Ausgaben

  • gutenTag(int n)
  • zufallsZahlen(int n)

Lernziel: Schleifenkopf sicher aufbauen, Wiederholungslogik verstehen.

Gruppe 2: Zaehlen

  • aufsteigend(int n)
  • absteigend(int n)

Lernziel: Startwert, Bedingung und Update gezielt variieren.

Gruppe 3: Summen und Reihen

  • summe(int n)
  • quadratSumme(int n)
  • geometrischeReihe(int n, double z)

Lernziel: Akkumulatorvariablen, numerische Genauigkeit, formelbasiertes Testen.

Gruppe 4: Arrays

  • zufall(int n)
  • arrayAufsteigend(int n)
  • Summen/Mittelwert-Funktionen auf Arrays
  • Auswahlsummen mit Schrittweite k

Lernziel: Schleifen plus Indexzugriff sicher kombinieren.

Beispielimplementierungen

public static void aufsteigend(int n) {
    for (int i = 1; i <= n; i++) {
        System.out.println(i);
    }
}

public static int summe(int n) {
    int s = 0;
    for (int i = 1; i <= n; i++) {
        s += i;
    }
    return s;
}

public static double mittelwert(int[] array) {
    if (array == null || array.length == 0) {
        return 0.0;
    }
    int s = 0;
    for (int i = 0; i < array.length; i++) {
        s += array[i];
    }
    return (double) s / array.length;
}

Typische Denkfehler bei Schleifen

  1. Off-by-one-Fehleri < n vs. i <= n falsch gewaehlt.
  2. Update vergessen Fuehrt zu Endlosschleife.
  3. Falscher Startindex bei Arrays Arrays beginnen bei 0, nicht bei 1.
  4. Bedingung und Ziel passen nicht zusammen Beispiel: absteigend zaehlen, aber i++ statt i--.
  5. Akkumulator nicht initialisiertsumme muss bei 0 starten.

Mathematische Tests als Qualitaetssicherung

Das Blatt nutzt bewusst Formeln als Gegencheck, z. B. fuer Summen.

Beispiel:

  • Schleife berechnet 1 + 2 + ... + n
  • Vergleich mit Gauss-Formel n * (n + 1) / 2

So wird schnell erkennbar, ob die Schleifenlogik korrekt ist.

Schleifen und Arrays: wiederkehrendes Muster

Viele Aufgaben folgen diesem Standardmuster:

for (int i = 0; i < array.length; i++) {
    // lese oder schreibe array[i]
}

Daraus lassen sich Varianten ableiten:

  • jedes Element
  • nur jedes k-te Element
  • Suche bis zum ersten Treffer
  • Zaehlung von Treffern

Dieses Muster sollte automatisiert beherrscht werden.

Uebungsblock zur Vertiefung

  1. Implementiere absteigend(int n) ohne Duplikatcode zu aufsteigend.
  2. Implementiere summeGerade(int n) fuer alle geraden Zahlen bis n.
  3. Implementiere count(int[] a, int gesucht).
  4. Implementiere indexVonErstemTreffer(int[] a, int gesucht) mit Rueckgabe -1 bei Nichtfund.
  5. Implementiere arrayAbsteigend(int n).
  6. Implementiere auswahlSumme(int[] a, int k) robust gegen k <= 0.

Wann for, wann while?

Pragmatische Regel:

  • for: wenn ein Zaehlmuster klar ist.
  • while: wenn ein Zustand/Abbruch dominiert (z. B. Eingabe lesen bis gueltig).

Beide sind gleichwertige Sprachmittel. Entscheidend ist Lesbarkeit.

Qualitaetsregeln fuer Schleifen-Code

  1. Schleifenkopf so einfach wie moeglich.
  2. Schleifenkoerper kurz halten, Teilaufgaben in Methoden auslagern.
  3. Randfaelle zuerst pruefen (null, leeres Array, n <= 0).
  4. Bei numerischen Aufgaben Zwischenresultate klar benennen (summe, produkt, zaehler).
  5. Testfaelle mit kleinen Zahlen starten, dann vergroessern.

Zusammenfassung

Das Arbeitsblatt vermittelt Schleifen nicht als isolierte Syntax, sondern als universelles Werkzeug fuer:

  • Ausgaben
  • Summen und Reihen
  • Arrayverarbeitung
  • Such- und Zaehlprobleme

Wer diese Aufgabenklasse sicher beherrscht, kann viele Standardprobleme in Java strukturiert loesen.

Abbildungen

In der zugeordneten Datei wurden keine eingebetteten Bildobjekte gefunden.

Schleifenkopf bewusst lesen

Im Arbeitsblatt wird der Kopf der for-Schleife sauber zerlegt. Fuer die Praxis hilft eine Standardlesart:

  • init: "Womit starte ich?"
  • test: "Wann laeuft es weiter?"
  • update: "Wie komme ich zum naechsten Schritt?"

Wenn eine dieser Fragen unklar bleibt, ist die Schleife meist fehleranfaellig.

Schleifeninvarianten als Denkwerkzeug

Bei mathematischen Aufgaben (Summen, Reihen) ist eine Schleifeninvariante sehr hilfreich:

Beispiel summe(int n):

  • Nach jedem Durchlauf i gilt: s enthaelt die Summe von 1 bis i.

Diese Formulierung erleichtert das Beweisen von Korrektheit und das Erkennen von Off-by-one-Fehlern.

for und while in aequivalente Formen umwandeln

Das Blatt zeigt diesen Transfer explizit. Beispiel:

for (int i = 0; i < 10; i++) {
    System.out.println(i);
}

entspricht

int i = 0;
while (i < 10) {
    System.out.println(i);
    i++;
}

Diese Umformung ist didaktisch stark, weil sie den Fokus auf Kontrolllogik statt auf Syntax legt.

Endlosschleifen frueh erkennen

Warnsignale:

  1. Bedingung haengt von Variable ab, die nie geaendert wird.
  2. Update bewegt sich in die falsche Richtung.
  3. Bedingung ist konstant true ohne break.

Beispiel:

int i = 0;
while (i < 10) {
    System.out.println(i);
    // i++ fehlt
}

Derartige Fehler sollten im Kurs aktiv als "Debug-Uebung" besprochen werden.

Summenaufgaben strukturiert loesen

Fuer Methoden wie summe, quadratSumme, geometrischeReihe empfiehlt sich ein Standardschema:

  1. Akkumulator initialisieren
  2. Schleife ueber passenden Indexbereich
  3. Term pro Durchlauf addieren
  4. Ergebnis zurueckgeben oder ausgeben

Schema:

double s = 0.0;
for (int i = 1; i <= n; i++) {
    s += term(i);
}
return s;

Dieses Muster deckt einen grossen Teil der Blattaufgaben ab.

Arrays plus Schleifen kombinieren

Viele EF.08-Aufgaben trainieren den Uebergang von Zahlenschleifen zu Arrayschleifen.

Beispiel arrayAufsteigend:

public static int[] arrayAufsteigend(int n) {
    int[] a = new int[n];
    for (int i = 0; i < n; i++) {
        a[i] = i + 1;
    }
    return a;
}

Wichtige Umstellung:

  • Zahlenfolgen starten oft bei 1
  • Arrayindizes starten bei 0

Dieser Unterschied ist eine haeufige Fehlerquelle.

Such- und Zaehlaufgaben

Ein naechster Schritt ueber reine Summen hinaus:

  • erstes Vorkommen finden
  • letztes Vorkommen finden
  • Anzahl Treffer zaehlen

Muster fuer Trefferzaehler:

int count = 0;
for (int i = 0; i < array.length; i++) {
    if (array[i] == gesucht) {
        count++;
    }
}

Solche Muster sind Grundlage vieler Pruefungsaufgaben.

Testdaten sinnvoll waehlen

Fuer Schleifenmethoden sollten Testfaelle nicht nur "normal" sein.

Empfohlene Faelle:

  1. n = 0
  2. n = 1
  3. kleiner Standardfall (n = 5)
  4. groesserer Fall (n = 1000)
  5. ungueltiger Fall (n < 0) falls relevant

Bei Arraymethoden zusaetzlich:

  • leeres Array
  • Array mit einem Element
  • Array mit Duplikaten

90-Minuten-Trainingsformat zu EF.08

  1. 15 min: Schleifenkopf und Leseregel
  2. 20 min: Summenmethoden
  3. 20 min: Arraymethoden
  4. 20 min: Suche/Zaehlung
  5. 15 min: Debugging typischer Fehler

Diese Taktung folgt der Progression des Arbeitsblatts.

Typische Fehlannahmen

  1. "for ist immer besser als while" -> falsch, Kontext entscheidet.
  2. "i <= array.length ist korrekt" -> meist falsch.
  3. "Mittelwert mit int-Division reicht" -> fuehrt zu abgeschnittenen Ergebnissen.
  4. "Wenn Ausgabe stimmt, ist Methode korrekt" -> nicht ohne Randfalltests.

Erweiterte Uebungsserie

  1. fakultaet(int n) mit Schleife
  2. istPrimzahl(int n) mit fruehem Abbruch
  3. summeJederKtenZahl(int[] a, int k)
  4. seqSearch(int[] a, int x)
  5. allePositiven(int[] a) als neues Array

Diese Serie verknuepft Schleifen mit Bedingungen, Arrays und Rueckgabewerten.

Fazit der Vertiefung

Das Arbeitsblatt EF.08 trainiert nicht nur Wiederholungssyntax, sondern algorithmisches Denken in kleinen, klaren Schritten. Wer die dortigen Muster verinnerlicht, kann einen grossen Teil alltaeglicher Einsteigerprobleme in Java sicher loesen.

Abschlussserie zu Schleifen

Erstelle eine Klasse SchleifenTraining mit den Methoden:

  1. long fakultaet(int n)
  2. int summeBis(int n)
  3. int anzahlTeiler(int n)
  4. boolean istPrimzahl(int n)

Vorgaben:

  • Jede Methode nutzt mindestens eine Schleife.
  • Fuer jede Methode sind drei Testfaelle zu dokumentieren.
  • Begruende kurz, warum for oder while gewaehlt wurde.

Diese Serie verbindet mathematisches Denken mit sauberer Schleifenstruktur und entspricht dem Uebungsziel von EF.08.

Pruefungsnahe Kurzfragen

  1. Wofuer stehen die drei Teile im Kopf einer for-Schleife?
  2. Wann ist eine while-Schleife geeigneter als for?
  3. Was ist ein Off-by-one-Fehler?
  4. Warum braucht der Mittelwert aus int-Werten oft einen Cast nach double?

Diese Fragen sichern das Begriffsverstaendnis hinter den Uebungsaufgaben.

Weiterfuehrende Praxisaufgabe

Schreibe eine Methode collatzLaenge(int n), die mit einer while-Schleife die Laenge der Collatz-Folge bestimmt.

Zusatz:

  1. Fuehre eine for-Schleife aus, die fuer n = 1..100 die maximale Laenge sucht.
  2. Gib den Wert von n und die maximale Laenge aus.

Diese Aufgabe trainiert Schleifenwahl, Abbruchbedingungen und saubere Auswertung in einem kompakten Projekt.

Mini-Reflexion

Bei Schleifenproblemen hilft ein kurzer Trockenlauf mit kleinen Zahlen fast immer schneller als direktes Umprogrammieren.