Statische Member in Java: static Felder und Methoden

Zur Klasse gehören, nicht zum Objekt

Die meisten Felder und Methoden, die du bisher geschrieben hast, gehören zu Objekten: Jedes Mal, wenn du new aufrufst, erhält jede Instanz ihre eigene Kopie der Felder, und Methoden arbeiten auf dem Zustand genau dieses Objekts. Das Schlüsselwort static kehrt das um. Ein static-Member gehört zur Klasse selbst - es gibt eine einzige Kopie, die von jeder Instanz geteilt wird, und sie existiert, ob du jemals ein Objekt erzeugst oder nicht.

Diese eine Unterscheidung erklärt static Felder, static Methoden, Konstanten und sogar, warum main immer static ist.

Ein geteiltes static-Feld

Ein nicht-statisches Feld gibt jedem Objekt seinen eigenen Platz. Ein static-Feld gibt der Klasse einen Platz, den alle teilen. Das klassische Beispiel ist ein Zähler, der festhält, wie viele Objekte erzeugt wurden:

class User {
    static int count = 0;     // ein geteilter Platz für die ganze Klasse
    String name;              // einer pro Objekt

    User(String name) {
        this.name = name;
        count++;              // den geteilten Zähler bei jeder Konstruktion erhöhen
    }
}

public class Main {
    public static void main(String[] args) {
        new User("Ada");
        new User("Linus");
        new User("Grace");

        System.out.println("users created: " + User.count);
    }
}

Beachte, dass du den Zähler als User.count ausliest - über den Klassennamen, weil der Wert zu keinem einzelnen User gehört. Jedes name hingegen lebt in seinem eigenen Objekt. Ändere count über eine beliebige Instanz, und jede Instanz sieht den neuen Wert, weil es nur einen davon gibt.

static Methoden

Eine static-Methode gehört ebenfalls zur Klasse, daher rufst du sie auf der Klasse ohne ein Objekt auf:

class MathUtils {
    static int square(int x) {
        return x * x;
    }

    static int max(int a, int b) {
        return a > b ? a : b;
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(MathUtils.square(7));
        System.out.println(MathUtils.max(3, 9));
    }
}

Genau dieses Muster steckt hinter der Standardbibliothek: Math.max, Integer.parseInt, Arrays.sort und List.of sind alle static - Hilfsverhalten, das kein Objekt zum Arbeiten benötigt. Greife zu einer static-Methode, wenn die Arbeit nur von ihren Argumenten abhängt und nicht von irgendeinem objektspezifischen Zustand.

Der große Stolperstein: static kann instance nicht sehen

Eine static-Methode läuft ohne jedes Objekt, es gibt also kein this. Das bedeutet, sie kann Instanzfelder nicht direkt ansprechen oder Instanzmethoden aufrufen - es gibt kein bestimmtes Objekt, aus dem sie sie auslesen könnte. Das ist der mit Abstand häufigste Anfängerfehler bei static:

class Account {
    int balance = 100;          // Instanzfeld

    static int show() {
        return balance;         // KOMPILIERFEHLER: auf das nicht-statische Feld 'balance'
    }                           // kann aus einem statischen Kontext nicht zugegriffen werden
}

Die Lösung ist entweder, die Methode zu einer Instanzmethode zu machen (static entfernen, sodass sie ein this hat), oder das Objekt explizit zu übergeben:

class Account {
    int balance = 100;

    static int show(Account a) {     // das Objekt als Parameter übernehmen
        return a.balance;
    }
}

public class Main {
    public static void main(String[] args) {
        Account a = new Account();
        System.out.println(Account.show(a));
    }
}

Die umgekehrte Richtung ist unproblematisch: Eine Instanzmethode darf static-Felder frei lesen und static-Methoden aufrufen, weil die geteilten Daten auf Klassenebene immer existieren.

Konstanten mit static final

Kombinierst du static mit final, erhältst du eine Konstante: einen einzigen geteilten Wert, der sich nie ändern kann. Per Konvention werden diese in UPPER_SNAKE_CASE benannt:

class Circle {
    static final double PI = 3.14159265;

    double radius;

    Circle(double radius) { this.radius = radius; }

    double area() {
        return PI * radius * radius;   // Instanzmethode, die eine static-Konstante nutzt
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.printf("%.2f%n", new Circle(2).area());
    }
}

static final ist die idiomatische Art, „einen festen Wert, der zum Typ gehört" auszudrücken - Dinge wie Integer.MAX_VALUE oder Math.PI in der Standardbibliothek. Es static zu machen bedeutet, dass du nicht pro Objekt eine Kopie verschwendest; es final zu machen bedeutet, dass niemand es neu zuweisen kann.

static Initialisierungsblöcke

Ein einfaches static-Feld kann inline initialisiert werden. Wenn die Einrichtung echte Logik benötigt - eine Nachschlagetabelle aufbauen, Konfiguration lesen - verwende einen static-Block. Er läuft einmal, wenn die Klasse zum ersten Mal geladen wird, bevor irgendein Objekt existiert:

import java.util.HashMap;
import java.util.Map;

class Roman {
    static final Map<Character, Integer> VALUES = new HashMap<>();

    static {                       // läuft einmal, beim Laden der Klasse
        VALUES.put('I', 1);
        VALUES.put('V', 5);
        VALUES.put('X', 10);
        VALUES.put('L', 50);
    }

    static int valueOf(char c) {
        return VALUES.get(c);
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(Roman.valueOf('X') + Roman.valueOf('I'));
    }
}

Der Block wird ein einziges Mal ausgelöst, egal wie oft du die Klasse verwendest, was ihn zum richtigen Ort für eine einmalige, klassenweite Einrichtung macht.

Wann man static verwendet

Eine schnelle Faustregel:

• Verwende ein static Feld nur für Daten, die wirklich von allen Instanzen geteilt werden - einen Zähler, einen Cache, eine Konstante. Wenn zwei Objekte vernünftigerweise unterschiedliche Werte halten könnten, sollte es stattdessen ein Instanzfeld sein.
• Verwende eine static Methode, wenn das Ergebnis nur von den Argumenten abhängt und nicht vom Zustand eines Objekts (reine Hilfsfunktionen).
• Bevorzuge standardmäßig Instanz-Member. Übermäßiger Einsatz von static verwandelt dein Programm stillschweigend in einen Haufen globalen Zustands, der schwer zu testen und nachzuvollziehen ist. static ist die Ausnahme, nicht der Ausgangspunkt.

Als Nächstes: Enums

Eine static final-Konstante eignet sich für einen einzelnen festen Wert, aber wenn du eine kleine, feste Menge verwandter Werte hast - Richtungen, Wochentage, Bestellstatus - bietet Java einen eigens dafür gemachten Typ, der sicherer und ausdrucksstärker ist als verstreute Konstanten. Das ist das enum, und es ist die nächste Seite.