Java-Methoden: Methoden definieren und aufrufen

Warum es Methoden gibt

Eine Methode ist ein benannter Codeblock, den du ausführen kannst, wann immer du seinen Namen aufrufst. Statt dieselben Zeilen immer wieder zu schreiben, schreibst du sie einmal in eine Methode und rufst sie so oft auf, wie du sie brauchst. Das macht Programme kürzer, leichter lesbar und weitaus einfacher zu korrigieren: Du änderst die Logik an einer Stelle und alle Aufrufer erhalten die Aktualisierung.

Du hast bereits Methoden aufgerufen: System.out.println(...) ist ein Methodenaufruf, und list.size() ebenfalls. Jetzt schreibst du deine eigenen.

Eine Methode deklarieren und aufrufen

Eine Methodendeklaration hat vier Teile: einen Rückgabetyp, einen Namen, ein Klammerpaar (für die Parameter) und einen Rumpf in geschweiften Klammern. Hier ist das kleinste sinnvolle Beispiel: eine Methode, die etwas Arbeit erledigt und nichts zurückgibt:

public class Main {
    static void printGreeting() {
        System.out.println("Hello from a method!");
    }

    public static void main(String[] args) {
        printGreeting();   // rufe sie auf
        printGreeting();   // rufe sie erneut auf
    }
}

Lies die Bestandteile von static void printGreeting():

• static: erlaubt main, sie direkt aufzurufen, ohne ein Objekt zu erzeugen (mehr dazu weiter unten).
• void: diese Methode gibt keinen Wert zurück.
• printGreeting: der Name, mit dem du sie aufrufst.
• (): leere Klammern bedeuten, dass sie keine Eingaben entgegennimmt.

Du rufst eine Methode auf, indem du ihren Namen gefolgt von Klammern schreibst. Die beiden Aufrufe in main führen den Rumpf zweimal aus, also gibt dies die Begrüßung zweimal aus.

Einen Wert zurückgeben

Die meisten Methoden berechnen etwas und geben es mit return zurück. Der Rückgabetyp vor dem Namen gibt an, welche Art von Wert herauskommt; hier int:

public class Main {
    static int square(int n) {
        return n * n;
    }

    public static void main(String[] args) {
        int result = square(5);
        System.out.println(result);          // 25
        System.out.println(square(3) + 1);   // 10
    }
}

square(5) wird zu 25 ausgewertet, das du in einer Variablen speichern, ausgeben oder in einem größeren Ausdruck verwenden kannst: Ein Methodenaufruf steht für den Wert, den er zurückgibt. In dem Moment, in dem return ausgeführt wird, endet die Methode und die Kontrolle springt zum Aufrufer zurück. Jeder Code nach einem return auf demselben Pfad wird nie ausgeführt.

Der Rückgabetyp und der zurückgegebene Wert müssen übereinstimmen. int zu deklarieren und return "text"; zu versuchen, ist ein Kompilierfehler: Der Compiler erzwingt den Vertrag.

void versus ein Rückgabetyp

Die Unterscheidung ist einfach: Verwende einen echten Rückgabetyp, wenn der Aufrufer einen Wert zurückbekommen muss, und void, wenn die Methode einfach nur etwas tut (ausgibt, speichert, einen Zustand aktualisiert).

void logMessage(String msg)   // erledigt Arbeit, gibt nichts zurück
int  add(int a, int b)        // berechnet einen Wert, den der Aufrufer nutzt

Ein häufiger Anfängerfehler ist der Versuch, das „Ergebnis" einer void-Methode zu verwenden:

int x = printGreeting();   // Kompilierfehler: printGreeting() gibt void zurück

Es gibt keinen Wert zum Zuweisen, daher lässt sich das nicht kompilieren. Wenn du merkst, dass du das Ergebnis einer void-Methode haben möchtest, ist das ein Zeichen, dass sie stattdessen etwas zurückgeben sollte.

Methoden, die verzweigen und früh zurückkehren

Du kannst von mehr als einer Stelle aus return verwenden. Früh zurückzukehren – sobald du die Antwort kennst – liest sich oft klarer, als alles in else zu verschachteln:

public class Main {
    static String grade(int score) {
        if (score >= 90) return "A";
        if (score >= 80) return "B";
        if (score >= 70) return "C";
        return "F";
    }

    public static void main(String[] args) {
        System.out.println(grade(95));   // A
        System.out.println(grade(72));   // C
        System.out.println(grade(50));   // F
    }
}

Da jedes return sofort verlässt, gewinnt die erste zutreffende Bedingung. Stelle nur sicher, dass jeder Pfad durch eine wertliefernde Methode mit einem return endet: Wenn ein Zweig durchlaufen kann, ohne etwas zurückzugeben, beschwert sich der Compiler mit „missing return statement". Das abschließende return "F"; deckt hier den Durchfallfall ab.

Was static hier bedeutet

Dir ist vielleicht aufgefallen, dass jede Methode oben static ist. Eine static-Methode gehört zur Klasse selbst, nicht zu einem Objekt, daher kann main (das ebenfalls static ist) sie direkt über ihren Namen aufrufen. Ohne static gehört die Methode zu einer Instanz und du bräuchtest ein Objekt, um sie darauf aufzurufen.

Solange du vorerst kleine Programme schreibst, deren Logik neben main liegt, markiere deine Hilfsmethoden als static, damit sie auf dieselbe Weise aufgerufen werden können. Sobald du anfängst, deine eigenen Klassen und Objekte zu erstellen, schreibst du auch nicht-statische (Instanz-)Methoden: Das kommt mit dem Kapitel über Klassen.

public class Main {
    static int doubleIt(int n) {
        return n * 2;
    }

    public static void main(String[] args) {
        // main ist static und kann doubleIt daher direkt aufrufen
        System.out.println(doubleIt(21));   // 42
    }
}

Lokale Variablen bleiben innerhalb der Methode

Variablen, die innerhalb einer Methode deklariert werden, existieren nur dort. Sie werden erzeugt, wenn die Methode läuft, und sind verschwunden, sobald sie zurückkehrt: Der Aufrufer sieht sie nie:

public class Main {
    static int sumTo(int limit) {
        int total = 0;                       // lokal in sumTo
        for (int i = 1; i <= limit; i++) {
            total += i;
        }
        return total;
    }

    public static void main(String[] args) {
        System.out.println(sumTo(100));      // 5050
        // System.out.println(total);        // Fehler: total ist hier nicht sichtbar
    }
}

total und i leben vollständig innerhalb von sumTo. Das Einzige, was die Methode verlässt, ist der Wert, den du per return zurückgibst. Diese Isolation ist ein Vorteil: Jede Methode ist eine in sich geschlossene Einheit, über die du nachdenken kannst, ohne dir Sorgen zu machen, dass ihre temporären Variablen nach außen dringen oder mit Namen anderswo kollidieren.

Als Nächstes: Methodenparameter

Jede Methode hier nahm entweder keine Eingabe oder einen einzelnen Wert entgegen. Die wahre Stärke kommt davon, Daten hineinzugeben – und Java hat spezifische Regeln dafür, wie Argumente übergeben werden, was bei Objekten im Vergleich zu primitiven Typen passiert und wie man einem Parameter eine Art Standardwert gibt. Darum geht es auf der nächsten Seite.