Kapitel 9: Methoden (Funktionen)

🎯 Lernziele

• Was Methoden sind und warum man sie braucht
• Methoden definieren und aufrufen
• Parameter und Rückgabewerte
• Methodenüberladung (Overloading)
• Methoden-Rekursion (Einstieg)

9.1 Was sind Methoden? Warum braucht man sie?

🔧 Methode = Code-Block mit Namen

Stell dir eine Methode wie eine Waschmaschine vor:

• Du wirfst Kleidung hinein (Parameter)
• Die Maschine wäscht (führt Code aus)
• Du nimmst saubere Kleidung heraus (Rückgabewert)

🤔 Warum brauchen wir Methoden?

Ohne Methoden	Mit Methoden
Code mehrfach kopieren	Code einmal schreiben, mehrfach aufrufen
Schwer zu warten	Leicht zu ändern
Unübersichtlich	Strukturiert und lesbar

→ Methoden machen Code wiederverwendbar und wartbar!

9.2 Methoden definieren und aufrufen

📝 Syntax

// Definition (in der Klasse, außerhalb von main)
static rückgabetyp methodenName(parameterliste) {
    // Code-Block
    return wert;  // (nur wenn rückgabetyp nicht void)
}

// Aufruf (in der main-Methode)
methodenName(argumente);

📋 Beispiel 1: Einfache Methode ohne Parameter und Rückgabe

public class MethodeBeispiel1 {
    // Methode definieren
    static void begruessung() {
        System.out.println("Hallo! Willkommen bei Java!");
    }
    
    public static void main(String[] args) {
        // Methode aufrufen
        begruessung();  // Gibt "Hallo! Willkommen bei Java!" aus
        begruessung();  // Kann mehrfach aufgerufen werden!
    }
}

Ausgabe:

Hallo! Willkommen bei Java!
Hallo! Willkommen bei Java!

📋 Beispiel 2: Methode mit Parameter

public class MethodeBeispiel2 {
    // Methode mit Parameter
    static void begruessePerson(String name) {
        System.out.println("Hallo, " + name + "!");
    }
    
    public static void main(String[] args) {
        // Methode mit Argument aufrufen
        begruessePerson("Max");
        begruessePerson("Anna");
    }
}

Ausgabe:

Hallo, Max!
Hallo, Anna!

9.3 Parameter und Rückgabewerte

📥 Parameter (Eingabe)

Parameter sind Variablen, die der Methode beim Aufruf übergeben werden.

static void methodeName(parameter1, parameter2, ...) {
    // Parameter werden innerhalb der Methode verwendet
}

📤 Rückgabewert (Ausgabe)

Rückgabewert ist das Ergebnis, das die Methode zurückgibt.

• void: Keine Rückgabe (kein return)
• Anderer Typ: Muss return wert; haben

📋 Beispiel 1: Methode mit Rückgabewert

public class RueckgabeBeispiel1 {
    // Methode mit Rückgabewert (int)
    static int quadrat(int zahl) {
        return zahl * zahl;  // Gibt Ergebnis zurück
    }
    
    public static void main(String[] args) {
        int ergebnis = quadrat(5);  // 5 ist Argument
        System.out.println("5² = " + ergebnis);  // 25
        
        // Oder direkt ausgeben
        System.out.println("10² = " + quadrat(10));  // 100
    }
}

📋 Beispiel 2: Methode mit mehreren Parametern

public class RueckgabeBeispiel2 {
    // Methode mit 2 Parametern
    static int maximum(int a, int b) {
        if (a > b) {
            return a;
        } else {
            return b;
        }
    }
    
    public static void main(String[] args) {
        int max = maximum(10, 20);
        System.out.println("Maximum: " + max);  // 20
    }
}

⚠️ Wichtig: return beendet die Methode!

static int testMethode(int x) {
    if (x > 0) {
        return x;  // Methode endet hier!
    }
    System.out.println("Diese Zeile wird nie erreicht, wenn x > 0!");
    return -1;
}

9.4 Verschiedene Methoden-Typen

Methoden-Typ	Syntax	Beispiel
Keine Parameter, keinen Rückgabewert	void name()	void druckeHallo()
Mit Parameter, keinen Rückgabewert	void name(typ param)	void begruesse(String name)
Keine Parameter, mit Rückgabewert	typ name()	int gibZufall()
Mit Parameter, mit Rückgabewert	typ name(typ param)	int addiere(int a, int b)

📋 Beispiel: Alle 4 Typen

public class AlleTypen {
    // Typ 1: Keine Parameter, keinen Rückgabewert
    static void druckeHallo() {
        System.out.println("Hallo!");
    }
    
    // Typ 2: Mit Parameter, keinen Rückgabewert
    static void druckeZahl(int z) {
        System.out.println("Zahl: " + z);
    }
    
    // Typ 3: Keine Parameter, mit Rückgabewert
    static int gibZehn() {
        return 10;
    }
    
    // Typ 4: Mit Parameter, mit Rückgabewert
    static int multipliziere(int a, int b) {
        return a * b;
    }
    
    public static void main(String[] args) {
        druckeHallo();
        druckeZahl(42);
        System.out.println(gibZehn());
        System.out.println(multipliziere(3, 4));  // 12
    }
}

9.5 Methodenüberladung (Overloading)

🔄 Was ist Überladung?

Methodenüberladung = Mehrere Methoden mit gleichem Namen, aber unterschiedlichen Parametern.

📋 Beispiel: addiere Methode überladen

public class UeberladungBeispiel {
    // Version 1: 2 int Parameter
    static int addiere(int a, int b) {
        return a + b;
    }
    
    // Version 2: 3 int Parameter
    static int addiere(int a, int b, int c) {
        return a + b + c;
    }
    
    // Version 3: 2 double Parameter
    static double addiere(double a, double b) {
        return a + b;
    }
    
    public static void main(String[] args) {
        System.out.println(addiere(10, 20));        // Ruft Version 1
        System.out.println(addiere(10, 20, 30));   // Ruft Version 2
        System.out.println(addiere(1.5, 2.5));    // Ruft Version 3
    }
}

Ausgabe:

30
60
4.0

✅ Regeln für Überladung

1. Gleicher Methodenname
2. Unterschiedliche Parameter (Anzahl oder Datentyp)
3. Rückgabetyp darf gleich oder verschieden sein (muss nicht!)

9.6 Methoden-Rekursion (Einstieg)

🔁 Was ist Rekursion?

Rekursion = Eine Methode ruft sich selbst auf.

📋 Beispiel: Fakultät berechnen (n!)

5! = 5 × 4 × 3 × 2 × 1 = 120

public class RekursionBeispiel {
    // Rekursive Methode
    static int fakultaet(int n) {
        if (n == 1) {
            return 1;  // Basisfall (Rekursionsende!)
        } else {
            return n * fakultaet(n - 1);  // Rekursiver Aufruf
        }
    }
    
    public static void main(String[] args) {
        System.out.println("5! = " + fakultaet(5));  // 120
    }
}

⚠️ Achtung: Endlosschleife (Stack Overflow!)

// ❌ Falsch: Kein Basisfall!
static int falscheRekursion(int n) {
    return n * falscheRekursion(n - 1);  // Nie endend!
}

→ Immer einen Basisfall definieren!

📝 Zusammenfassung

In diesem Kapitel hast du gelernt:

• ✅ Methoden sind wiederverwendbare Code-Blöcke
• ✅ Methoden definieren und aufrufen
• ✅ Parameter (Eingabe) und Rückgabewerte (Ausgabe)
• ✅ Die 4 Methoden-Typen
• ✅ Methodenüberladung (Overloading)
• ✅ Rekursion (Methode ruft sich selbst auf)

💡 Merksatz für Anfänger

"Methoden = Code organisieren. void = keine Rückgabe, return = Ergebnis zurückgeben!"

🎯 Nächste Schritte

Im nächsten Kapitel lernst du:

• Objektorientierte Programmierung (OOP) Grundlagen (Kapitel 10)
• Was sind Klassen und Objekte?
• Objekte erstellen und verwenden
• Konstruktoren und this Schlüsselwort

Bereit für OOP? Los geht's! 🚀

---

📚 Weiterführende Links:

• Oracle Java Tutorials - Methods
• Java Method Overloading

💬 Fragen?
Hinterlassen Sie einen Kommentar!