CodeGym /Kurse /JAVA 25 SELF /Initialisierung statischer und final Felder

Initialisierung statischer und final Felder

JAVA 25 SELF
Level 15, Lektion 3
Verfügbar

1. Statische Felder: wie initialisieren?

Ein statisches Feld (static) gehört nicht einem Objekt, sondern der Klasse als Ganzes. Sein Wert existiert in genau einer Instanz für alle Objekte dieser Klasse. Als Analogie – das ist wie eine „Gemeinschaftskasse“ für alle Mitarbeitenden eines Unternehmens: Egal, wer gerade kommt, die Kasse ist für alle dieselbe.

Initialisierung bei der Deklaration

Die einfachste und gängigste Methode zur Initialisierung eines statischen Feldes ist, ihm den Wert direkt bei der Deklaration zuzuweisen:

public class User {
    private static int userCount = 0; // Initialisierung direkt hier

    // ... restlicher Code
}

Dieses Feld wird beim ersten Laden der Klasse User in den Speicher initialisiert.

Initialisierung im statischen Block

Manchmal ist eine komplexere Initialisierungslogik erforderlich – zum Beispiel Daten aus einer Datei laden oder Berechnungen durchführen. In diesem Fall verwendet man einen statischen Initialisierungsblock:

public class Config {
    public static String configPath;

    static {
        // Dieser Block wird EINMAL beim Laden der Klasse ausgeführt
        configPath = System.getenv("APP_CONFIG_PATH");
        if (configPath == null) {
            configPath = "/etc/app/default.conf";
        }
        System.out.println("Config path initialisiert: " + configPath);
    }
}

Wann wird der statische Block aufgerufen?

  • Beim ersten Zugriff auf die Klasse (z. B. beim Erzeugen des ersten Objekts oder beim Aufruf einer beliebigen statischen Methode/eines statischen Feldes).
  • Wird für jede Klasse nur ein einziges Mal ausgeführt.

Besonderheiten des Zugriffs auf statische Felder

  • Auf statische Felder greift man über den Klassennamen zu: User.userCount.
  • Man kann auch über das Objekt zugreifen, aber das gilt als schlechter Stil (es verwirrt die Lesenden des Codes).

Beispiel:

User u1 = new User();
User u2 = new User();
System.out.println(User.userCount); // richtig
System.out.println(u1.userCount);   // funktioniert, aber nicht empfohlen!

2. final-Felder: wann und wie initialisieren?

final ist ein Modifikator, der sagt: „Dieses Feld darf nur einmal zugewiesen werden und wird danach nicht mehr geändert.“ Nach der Initialisierung wird der Wert des Feldes unveränderlich: Für ein Objekt ist es eine feste Eigenschaft, für eine Klasse (wenn das Feld statisch ist) eine gemeinsame Konstante.

Anwendungsbeispiele:

  • Konstanten (z. B. PI).
  • Eine eindeutige Objekt-ID, die nach der Erstellung nicht geändert werden darf.

Anforderungen an die Initialisierung von final-Feldern

In Java gibt es eine strenge Regel: Jedes final-Feld muss entweder bei der Deklaration oder in jedem Konstruktor der Klasse initialisiert werden.

Initialisierung bei der Deklaration

public class Circle {
    public static final double PI = 3.1415926535; // Klassenkonstante
    private final String id = "CIRCLE";           // Objektkonstante
}

Initialisierung im Konstruktor

Manchmal ist der Wert eines final-Feldes erst bei der Objekterzeugung bekannt:

public class User {
    private final int id;

    public User(int id) {
        this.id = id; // weisen das final-Feld im Konstruktor zu
    }
}

Wichtig: Wenn eine Klasse mehrere Konstruktoren hat, muss das final-Feld in jedem einzelnen initialisiert werden!

Kombiniertes Beispiel

public class Token {
    private final String value;
    private final long timestamp;

    public Token(String value) {
        this.value = value;
        this.timestamp = System.currentTimeMillis();
    }
}

Kompilierungsfehler bei fehlerhafter Initialisierung

Wenn Sie vergessen, ein final-Feld zu initialisieren, lässt der Compiler das Programm nicht bauen:

public class Broken {
    private final int x; // nicht initialisiert

    public Broken() {
        // x wird nicht zugewiesen!
    }
}
// Fehler: variable x might not have been initialized

3. Kombination von static und final: Deklaration von Klassenkonstanten

Sehr häufig begegnet die Kombination public static final. In Java deklariert man damit Klassenkonstanten – Werte, die einmal festgelegt werden und sich während der Programmausführung nicht ändern. Diese Konstanten gehören der gesamten Klasse und sind für all ihre Objekte gleich.

Syntax und Beispiel

public class MathUtils {
    public static final double PI = 3.1415926535;
    public static final String APP_NAME = "MyApp";
}

Erläuterung:

  • public – überall zugänglich.
  • static – gehört der Klasse als Ganzes, nicht einem einzelnen Objekt.
  • final – nach der Initialisierung nicht mehr veränderbar.

Verwendung

double area = MathUtils.PI * r * r;
System.out.println(MathUtils.APP_NAME);

Konvention: Konstantennamen werden üblicherweise in GROSSBUCHSTABEN_MIT_UNTERSTRICH geschrieben.

4. Codebeispiele: Varianten der Initialisierung statischer und final Felder

Beispiel 1: Einfache Klasse mit Konstante

public class Constants {
    public static final int DAYS_IN_WEEK = 7;
    public static final String COMPANY = "Daisy LLC";
}

Beispiel 2: Statisches Feld, im statischen Block initialisiert

public class AppConfig {
    public static final String DEFAULT_PATH;

    static {
        // Hier kann komplexe Logik ausgeführt werden
        String env = System.getenv("APP_PATH");
        if (env != null) {
            DEFAULT_PATH = env;
        } else {
            DEFAULT_PATH = "/usr/local/app";
        }
    }
}

Beispiel 3: final-Feld eines Objekts, Initialisierung im Konstruktor

public class User {
    private static int nextId = 1;
    private final int id;
    private String name;

    public User(String name) {
        this.id = nextId++;
        this.name = name;
    }

    public int getId() { 
        return id; 
    }
    public String getName() {
        return name; 
    }
    public void setName(String name) { 
        this.name = name; 
    }
}

Verwendung:

User u1 = new User("John");
User u2 = new User("Maria");
System.out.println(u1.getId()); // 1
System.out.println(u2.getId()); // 2

Beispiel 4: Fehler bei falscher Initialisierung eines final-Feldes

public class BadExample {
    private final int number;

    public BadExample() {
        // number ist nicht initialisiert!
    }
}
// Kompilierungsfehler: variable number might not have been initialized

5. Best Practices im Umgang mit statischen und final-Feldern

Verwenden Sie public static final nur für echte Konstanten

Wenn sich der Wert künftig ändern kann (z. B. eine Mitarbeitendenliste), machen Sie ihn nicht final! Konstanten müssen wirklich unveränderlich sein.

public static final int MAX_USERS = 1000; // gut
public static final String[] USERS = new String[100]; // schlecht!

Zwar ändert sich die Referenz USERS nicht, aber der Inhalt des Arrays kann verändert werden. Das kann zu unerwarteten Fehlern führen.

Für komplexe Initialisierung statische Blöcke verwenden

Wenn sich die Konstante nicht durch eine einfache Zuweisung ausdrücken lässt (z. B. ist eine Berechnung oder das Lesen aus einer Datei erforderlich), verwenden Sie einen statischen Block.

Verwenden Sie statische Felder nicht übermäßig

Statische Felder sind globale Variablen. Zu viele davon können zu schwer auffindbaren Fehlern und zu schwieriger Wartbarkeit führen.

Machen Sie veränderbare Objekte nicht public static final

Wenn ein Objekt veränderbar ist, machen Sie es nicht öffentlich und final. Dadurch wird sein Inneres für alle zugänglich, und jemand wird das früher oder später ausnutzen.

6. Typische Fehler bei der Initialisierung statischer und final Felder

Fehler Nr. 1: Nicht initialisiertes final-Feld. Wenn man vergisst, ein final-Feld entweder bei der Deklaration oder in allen Konstruktoren zu initialisieren, meldet der Compiler einen Fehler. Wenn eine Klasse beispielsweise zwei Konstruktoren hat und man in einem davon die Zuweisung des final-Feldes vergisst – gibt es einen Fehler.

Fehler Nr. 2: Änderung des Wertes eines final-Feldes. Der Versuch, den Wert eines final-Feldes nach der Initialisierung zu ändern, führt zu einem Kompilierungsfehler.

public class Demo {
    private final int x = 5;
    public void change() {
        x = 10; // Fehler: cannot assign a value to final variable x
    }
}

Fehler Nr. 3: Öffentliche veränderbare static final Felder. Wenn man ein veränderbares Objekt (String[], int[] usw.) public static final macht, kann beliebiger Code dessen Inhalt ändern. Das verletzt die Kapselung und kann zu schwer auffindbaren Fehlern führen.

Fehler Nr. 4: Verwendung nichtstatischer Felder in einem statischen Block. In einem statischen Block darf man nicht auf nichtstatische Felder zugreifen, weil sie noch nicht initialisiert sind (und zu diesem Zeitpunkt überhaupt nicht existieren).

Fehler Nr. 5: Unerwartete Initialisierungsreihenfolge. Wenn Sie in einem statischen Block auf statische Felder zugreifen, die weiter unten im Code deklariert sind, sind diese möglicherweise noch nicht initialisiert. Deklarieren Sie statische Felder immer vor statischen Blöcken, wenn Sie vorhaben, sie zu verwenden.

1
Aufgabe
JAVA 25 SELF, Level 15, Lektion 3
Gesperrt
Globaler Zähler aktiver Nutzer 🌐
Globaler Zähler aktiver Nutzer 🌐
1
Aufgabe
JAVA 25 SELF, Level 15, Lektion 3
Gesperrt
Unveränderlicher Name auf dem Studentenausweis 📝
Unveränderlicher Name auf dem Studentenausweis 📝
1
Aufgabe
JAVA 25 SELF, Level 15, Lektion 3
Gesperrt
Festlegung der Startsprache der Anwendung ⚙️
Festlegung der Startsprache der Anwendung ⚙️
1
Aufgabe
JAVA 25 SELF, Level 15, Lektion 3
Gesperrt
Fundamentale Konstanten für Berechnungen ⚛️
Fundamentale Konstanten für Berechnungen ⚛️
Kommentare
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION