Statische Methoden

Worum geht´s?

Wenn wir ein Programm schreiben das mehr als einige wenige 100 Zeilen hat, wird es rasch sehr unübersichtlich. Mehrfach verschachtelte if/else bzw. Schleifen führen dazu, dass ein Programm irgendwann nur noch schwer nachzuvollziehen ist. Java erlaubt es, „Unterprogramme“ zu erstellen, die dann anhand des Namens mit verschiedenen Parametern aufgerufen werden können. In dem meisten Programmiersprachen heißen diese Funktionen. In Java nennt man sie stattdessen Methoden. Davon gibt es verschiedenste Varianten. Für den Anfang beginnen wir einfach mit sogenannten statischen Methoden.

1. Eine einfache statische Methode

Eine sehr einfache statische Methode könnte z.B. die Funktion haben, einen vorher definierten Text auszugeben.

Nennen wir unsere Methode doch einfach mal sayHi(). Unsere Methode sayHi() soll einfach den Text „Hi!“ 1x ausgeben, wenn sie aufgerufen wird:

public class StatischeMethoden {
    public static void main(String[] args) {
        sayHi();
    }
    
    public static void sayHi() {
        System.out.println("Hi!");
    }
}

Die Methode selbst wird dabei innerhalb der Klasse, aber außerhalb der main-Methode definiert. Ob sie darunter oder darüber definiert wird, spielt dabei technisch betrachtet keine Rolle. Der Einfachheit halber werden wir sie aber eher unterhalb der main-Methode einfügen.

Innerhalb der main-Methode (die eben auch eine, wenn auch spezielle, Methode ist) können wir nun mit Hilfe von sayHi(); unsere Methode aufrufen. Wenn wir das tun, wird unsere Methode für uns „Hi!“ in der Konsole ausgeben:

Hi!

Wollen wir, dass unser „Hi!“ mehrfach ausgegeben wird, so können wir unsere Methode sayHi() innerhalb der main-Methode einfach mehrfach ausrufen:

public static void main(String[] args) {
        sayHi();
        sayHi();
        sayHi();
    }

Das Ergebnis ist dann eben 3x unser „Hi!“:

Hi!
Hi!
Hi!

2. Eine einfache statische Methode mit Parametern

Was aber, wenn wir beispielsweise 100x „Hi!“ ausgeben wollen? Dann ist es ja etwas anstrengend, hier 100x sayHi() in unsere main-Methode schreiben zu müssen.

Eine Lösung wäre es, eine Schleife rund um unseren sayHi()-Aufruf zu packen, also in etwa so:

public static void main(String[] args) {
    for (int i = 0; i < 100; i++) {
        sayHi();
    }
}

Was aber, wenn wir z.B. 100x „Hi!“ haben wollen, dann 1x „Hi back!“ und dann wieder 50x „Hi!“? Dann müssten wir wohl mehrere Schleifen in unserer main-Methode benutzen.

Es gibt aber auch eine andere Lösung: Wir können unserer sayHi()-Methode Parameter mitgeben, wie oft sie „Hi!“ ausgeben soll, und die Schleife in die sayHi()-Methode packen:

public class StatischeMethoden {
    public static void main(String[] args) {
        sayHi(100);
        System.out.println("Hi back!");
        sayHi(20);
    }

    public static void sayHi(int howOften) {
        for (int i = 0; i < 100; i++) {
            System.out.println("Hi!");
        }
    }
}

Die obige Lösung gibt 100x „Hi!“ aus, dann 1x „Hi back!“ und dann wieder 20x „Hi!“, obwohl wir dafür nur an 1 Stelle unsere Schleife implementieren müssen.

3. Eine statische Methode mit mehreren Parametern

Eine statische Methode muss dabei nicht auf einen einzigen Parameter beschränkt sein. So können wir z.B. eine Methode hoch() erstellen, die uns aus zwei Zahlen a und b das Ergebnis für a^b ausgibt:

public static void main(String[] args) {
    hoch(3, 3);
}

public static void hoch(int a, int b) {
    int result = 1;
    for (int i = 0; i < b; i++) {
        result *= a;
    }
    System.out.println(result);
}

Das Ergebnis wäre in diesem Fall z.B.:

27

Du kannst so viele Parameter benutzen wie du willst. Wichtig ist nur, dass in der Definition der Methode gleich viele Parameter vorkommen wie dort, wo du die Methode aufrufst (in diesem Fall in der main-Methode), und dass die Datentypen die gleichen sind.

In der main-Methode könntest du z.B. nicht schreiben hoch(2), weil das zu wenige Parameter sind. Du kannst auch nicht schreiben hoch(‚X‘, 1), weil die Datentypen falsch sind.

Grundsätzlich kannst du aber jeden Datentyp als Parameter benutzen, also z.B. auch Strings, Arrays, ArrayList usw.

4. Statische Methoden mit Rückgabewerten

Bei einer mathematischen Berechnung wie vorhin ist es zwar nett, das Ergebnis in der Konsole lesen zu können. Aber meistens wollen wir mit einem Zwischenergebnis dann auch weiter rechnen. Deswegen ist es in Java (wie in fast allen Programmiersprachen) auch möglich, Ergebnisse zurückzugeben.

Bisher haben wir immer geschrieben „public static void NAME()“, ohne darüber nachzudenken. Das Wort „void“ bedeutet dabei, dass die Methode nichts zurückgibt. Das ist z.B. dort sinnvoll, wo die Methode einfach nur etwas zeichnen soll.

Wenn die Methode aber ein Ergebnis zurückgeben soll, dann müssen wir statt void den entsprechenden Datentyp einfügen, also z.B. so:

public static void main(String[] args) {
    int ergebnis = hoch(3, 3);
    System.out.println(ergebnis); // gibt 27 aus, weil in Ergebnis jetzt 27 steht
}

public static int hoch(int a, int b) {
    int result = 1;
    for (int i = 0; i < b; i++) {
        result *= a;
    }
    return result; // gibt den Wert von result zurück
}

5. Mehr als einen Rückgabewert zurückgeben

Manchmal kann es Sinn machen, in einer Methode mehr als 1 Ergebnis zurückzugeben.

Dazu gibt es verschiedene Techniken – die einfachste ist es, mit Arrays oder ArrayList zu arbeiten. So kann z.B. aus einem mehrdimensionalen Array ein Teil-Array über einen Index herausgeholt werden:

public static void main(String[] args) {
    String[][] movies = {
            // {title, time, roomNr, seatsLeft}
            {"Batman", "20:15", "1", "10"},
            {"Matrix", "22:00", "3", "2"},
            {"Matrix 2", "17:00", "2", "0"},
            {"Matrix 3", "19:00", "5", "100"},
    };

    String[] movie1 = movieAtIndex(movies, 1);
    System.out.println(Arrays.toString(movie1));

    String[] movie7 = movieAtIndex(movies, 7);
    System.out.println(Arrays.toString(movie7));
}

public static String[] movieAtIndex(String[][] movies, int index) {
    if (index >= 0 && index < movies.length)
        return movies[index];
    else
        return new String[0];
}

Die Methode movieAtIndex() prüft dabei, ob die Index-Nummer überhaupt existiert. Wenn ja, wird der Teil-Array des jeweiligen Films zurückgegeben. Wenn nein, wird ein leerer String-Array zurückgegeben. Die Ausgabe aus der main-Methode wäre dann entsprechend (Film 1 existiert, Film 7 nicht):

[Matrix, 22:00, 3, 2]
[]

Mit Hilfe eines Arrays ist es dann z.B . auch möglich, X/Y-Koordinaten eines Punkts gemeinsam zurückzugeben.

Diskussion zum Tutorial