Zwischenstufe Java Tag 4: Methoden & Rekursion

Ziel dieses Tages

Heute wirst du lernen:

• Methodenüberladung
• Grundlagen der Rekursion
• Rekursive Algorithmen (Fakultät, Fibonacci)
• Tail-Rekursion und Stack-Grenzen

Am Ende wirst du in der Lage sein, rekursive Methoden zu schreiben und zu verstehen, wie Rekursion in Java funktioniert.

Schritt 1: Methodenüberladung

Methodenüberladung erlaubt es dir, mehrere Methoden mit demselben Namen, aber unterschiedlichen Parametern zu erstellen.

public static int add(int a, int b) {
    return a + b;
}

public static double add(double a, double b) {
    return a + b;
}

Erklärung:

• Java wählt die passende Methode basierend auf den übergebenen Argumenten
• Hilft dabei, konsistente Methodennamen zu verwenden

Schritt 2: Grundlagen der Rekursion

Eine rekursive Methode ruft sich selbst auf, bis eine Abbruchbedingung erfüllt ist.

public static int factorial(int n) {
    if(n == 0) return 1;
    return n * factorial(n - 1);
}

System.out.println(factorial(5)); // 120

Erklärung:

• Basisfall: stoppt die Rekursion (n == 0)
• Rekursiver Fall: ruft sich selbst mit einem kleineren Wert auf

Schritt 3: Rekursive Algorithmen

Fakultät

public static int factorial(int n) {
    if(n == 0) return 1;
    return n * factorial(n - 1);
}

Fibonacci

public static int fibonacci(int n) {
    if(n == 0) return 0;
    if(n == 1) return 1;
    return fibonacci(n - 1) + fibonacci(n - 2);
}

Schritt 4: Tail-Rekursion & Stack-Grenzen

Tail-Rekursion ist eine Art der Rekursion, bei der der rekursive Aufruf die letzte Operation ist.

Beispiel (Fakultät mit Tail-Rekursion):

public static int factorialTail(int n, int result) {
    if(n == 0) return result;
    return factorialTail(n - 1, n * result);
}

Hinweis:

• Java optimiert Tail-Rekursion nicht automatisch
• Zu tiefe Rekursion kann einen StackOverflowError verursachen

Übung

public static int factorial(int n) {
    if(n == 0) return 1;
    return n * factorial(n - 1);
}

System.out.println(factorial(5)); // 120

Aufgabe

Schreibe eine rekursive Methode zur Berechnung der n-ten Fibonacci-Zahl.

Schritte:

• Erstelle eine Methode fibonacci(int n)
• Basisfälle: n = 0 → 0, n = 1 → 1
• Rekursiver Fall: fibonacci(n - 1) + fibonacci(n - 2)
• Teste deine Methode mit verschiedenen Werten für n

Beispiel:

public class Fibonacci {
    public static int fibonacci(int n) {
        if(n == 0) return 0;
        if(n == 1) return 1;
        return fibonacci(n - 1) + fibonacci(n - 2);
    }

    public static void main(String[] args) {
        System.out.println(fibonacci(10)); // 55
    }
}