Methoden Grundlagen in Java

Stell dir vor, du muesstest jedes Mal den gleichen Code schreiben, wenn du jemanden begruessen willst. Das waere muehsam! Methoden loesen dieses Problem: Sie sind wiederverwendbare Code-Bloecke mit einem Namen, die du beliebig oft aufrufen kannst.

Was sind Methoden?

In Java heissen sie Methoden (in Python: Funktionen). Eine Methode fasst Code zusammen und gibt ihm einen Namen:

public class Begruessung {

    // Methode definieren
    static void sagHallo() {
        System.out.println("Hallo!");
        System.out.println("Willkommen bei Java!");
    }

    public static void main(String[] args) {
        // Methode aufrufen
        sagHallo();
        sagHallo(); // So oft du willst!
    }
}

Ausgabe:

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

Aufbau einer Methode

[Modifizierer] Rueckgabetyp methodenName([Parameter]) {
    // Methoden-Koerper
    [return wert;]
}

Teil	Beschreibung	Beispiel
Modifizierer	Sichtbarkeit und Verhalten	public, static, private
Rueckgabetyp	Was die Methode zurueckgibt	void, int, String
Name	Bezeichnung (camelCase)	berechneNote, istGueltig
Parameter	Eingabewerte (optional)	(int alter, String name)
Koerper	Der auszufuehrende Code	{ ... }

Beispiele

// Kein Parameter, kein Rueckgabewert
static void zeigeLinie() {
    System.out.println("==================");
}

// Mit Parameter, kein Rueckgabewert
static void begruesse(String name) {
    System.out.println("Hallo " + name + "!");
}

// Mit Parameter und Rueckgabewert
static int verdopple(int zahl) {
    return zahl * 2;
}

void-Methoden

void bedeutet: Die Methode gibt keinen Wert zurueck. Sie fuehrt nur Code aus:

static void zeigeMenue() {
    System.out.println("=== Hauptmenue ===");
    System.out.println("1. Neues Spiel");
    System.out.println("2. Laden");
    System.out.println("3. Beenden");
    System.out.println("==================");
}

static void trennlinie(int laenge) {
    for (int i = 0; i < laenge; i++) {
        System.out.print("-");
    }
    System.out.println();
}

public static void main(String[] args) {
    zeigeMenue();
    trennlinie(30);
}

Fruehes return in void-Methoden

Auch void-Methoden koennen return verwenden — um vorzeitig abzubrechen:

static void pruefeAlter(int alter) {
    if (alter < 0) {
        System.out.println("Ungueltiges Alter!");
        return; // Methode sofort beenden
    }

    if (alter >= 18) {
        System.out.println("Volljaehrig!");
    } else {
        System.out.println("Minderjaehrig.");
    }
}

Methoden mit Rueckgabewert

Wenn eine Methode ein Ergebnis berechnet, kann sie es mit return zurueckgeben:

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

static double berechneKreisFlaeche(double radius) {
    return Math.PI * radius * radius;
}

static boolean istVolljährig(int alter) {
    return alter >= 18;
}

static String begruessungsText(String name) {
    return "Hallo " + name + ", willkommen!";
}

public static void main(String[] args) {
    var summe = addiere(5, 3);
    System.out.println("Summe: " + summe); // 8

    var flaeche = berechneKreisFlaeche(5.0);
    System.out.printf("Flaeche: %.2f%n", flaeche); // 78.54

    if (istVolljährig(20)) {
        System.out.println("Zutritt erlaubt!");
    }

    System.out.println(begruessungsText("Max"));
}

Wichtig: return beendet die Methode

Nach return wird kein Code mehr ausgefuehrt:

static int maximum(int a, int b) {
    if (a > b) {
        return a;
    }
    return b;
    // Kein Code hier -- wird nie erreicht
}

Vergleich mit Python

# Python: def, kein Typ noetig
def addiere(a, b):
    return a + b

def sag_hallo(name):
    print(f"Hallo {name}!")

// Java: Typ fuer Parameter und Rueckgabe noetig
static int addiere(int a, int b) {
    return a + b;
}

static void sagHallo(String name) {
    System.out.println("Hallo " + name + "!");
}

Python	Java
def	Rueckgabetyp + Name
Kein Typ	Typ fuer alles
None (implizit)	void (explizit)
Einrueckung = Block	Klammern {} = Block

static vs. non-static

Im Moment verwenden wir static bei allen Methoden. Was bedeutet das?

public class Rechner {

    // static: Gehoert zur KLASSE, nicht zu einem Objekt
    static int addiere(int a, int b) {
        return a + b;
    }

    // Aufruf: direkt ueber die Klasse
    public static void main(String[] args) {
        var ergebnis = addiere(5, 3); // Kein Objekt noetig
        // Oder: Rechner.addiere(5, 3)
    }
}

Spaeter, wenn wir OOP lernen, werden wir Methoden ohne static schreiben:

public class Hund {
    String name;

    // non-static: Gehoert zu einem OBJEKT
    void bellen() {
        System.out.println(name + " sagt: Wuff!");
    }
}

// Aufruf: ueber ein Objekt
var hund = new Hund();
hund.name = "Rex";
hund.bellen(); // "Rex sagt: Wuff!"

Fuer jetzt: Nutze static fuer alle Methoden in der main-Klasse.

Best Practices

1. Eine Methode, eine Aufgabe

// SCHLECHT: Macht zu viel
static void verarbeiteBestellung(String name, double preis, int menge) {
    // Preis berechnen, Rechnung erstellen, E-Mail senden, Lager aktualisieren...
}

// GUT: Aufgeteilt
static double berechneGesamtpreis(double preis, int menge) {
    return preis * menge;
}

static String erstelleRechnung(String name, double betrag) {
    return "Rechnung fuer " + name + ": " + betrag + " EUR";
}

2. Sprechende Namen

// SCHLECHT:
static int calc(int a, int b) { return a + b; }
static boolean check(int x) { return x > 0; }

// GUT:
static int berechneGesamtpreis(int einzelpreis, int menge) {
    return einzelpreis * menge;
}

static boolean istPositiv(int zahl) {
    return zahl > 0;
}

3. Methoden nicht zu lang

Eine gute Faustregel: Eine Methode sollte nicht mehr als 20-30 Zeilen haben. Wenn sie laenger wird, teile sie auf.

Praktisches Beispiel: Notenrechner

import java.util.Scanner;

public class NotenRechner {

    static double berechneDurchschnitt(double[] noten) {
        var summe = 0.0;
        for (var note : noten) {
            summe += note;
        }
        return summe / noten.length;
    }

    static String bewerteNote(double note) {
        if (note <= 1.5) return "Sehr gut";
        if (note <= 2.5) return "Gut";
        if (note <= 3.5) return "Befriedigend";
        if (note <= 4.0) return "Ausreichend";
        return "Nicht bestanden";
    }

    static void zeigeErgebnis(double durchschnitt) {
        System.out.printf("Durchschnitt: %.1f%n", durchschnitt);
        System.out.println("Bewertung: " + bewerteNote(durchschnitt));
    }

    public static void main(String[] args) {
        double[] noten = {1.7, 2.3, 1.0, 3.0, 2.7};

        var durchschnitt = berechneDurchschnitt(noten);
        zeigeErgebnis(durchschnitt);
    }
}

Uebungen

Uebung 1: Hilfsmethoden

Schreibe Methoden zeigeUeberschrift(String text) und zeigeTrennlinie(), die eine formatierte Ueberschrift mit Trennlinien ausgeben.

Uebung 2: Mathematik

Schreibe Methoden fuer istGerade(int zahl), istPrimzahl(int zahl) und fakultaet(int n).

Uebung 3: String-Helfer

Schreibe eine Methode wiederhole(String text, int anzahl), die einen Text mehrfach wiederholt und zurueckgibt (z.B. wiederhole("Ha", 3) ergibt "HaHaHa").

Uebung 4: Temperatur

Schreibe zwei Methoden: celsiusZuFahrenheit(double c) und fahrenheitZuCelsius(double f).

Was kommt als Naechstes?

In der naechsten Lektion vertiefen wir das Thema Methoden: Parameter und Rueckgabewerte im Detail, inklusive mehrerer Parameter, Standardwerte und der Frage, ob Java “by value” oder “by reference” arbeitet.

Zusammenfassung

• Methoden sind wiederverwendbare Code-Bloecke mit einem Namen
• void bedeutet “kein Rueckgabewert”, andere Typen erfordern return
• Methoden haben Modifizierer, Rueckgabetyp, Name und optionale Parameter
• static Methoden gehoeren zur Klasse, nicht zu einem Objekt
• Eine Methode = eine Aufgabe — halte Methoden kurz und fokussiert
• Verwende sprechende Namen in camelCase
• return beendet die Methode und gibt optional einen Wert zurueck

---