Statische Felder und Konstanten
Verwenden Sie statische Felder für gemeinsam genutzten Zustand, Konstanten mit static final und statische Initialisierer.
Statische Felder und Konstanten ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.
Statische Felder und Konstanten
Statische Felder gehören zur Klasse, nicht zu den Instanzen. Sie werden von allen Objekten der Klasse gemeinsam genutzt. Konstanten kombinieren static und final, um unveränderliche Werte auf Klassenebene zu erstellen.
Statische und Instanzfelder
Ein Instanzfeld hat für jedes Objekt eine eigene Kopie. Ein statisches Feld hat eine einzige Kopie, die von allen Objekten der Klasse gemeinsam genutzt wird.
class Counter {
private static int totalCount = 0; // shared across all instances
private int instanceId; // unique per instance
Counter() {
totalCount++;
instanceId = totalCount;
}
static int getTotalCount() { return totalCount; }
int getInstanceId() { return instanceId; }
}
Counter c1 = new Counter();
Counter c2 = new Counter();
Counter c3 = new Counter();
System.out.println(Counter.getTotalCount()); // 3
System.out.println(c1.getInstanceId()); // 1
System.out.println(c3.getInstanceId()); // 3Konstanten mit static final
Deklarieren Sie Konstanten als public static final. Konventionell verwenden sie SCREAMING_SNAKE_CASE.
class MathConstants {
public static final double PI = 3.141592653589793;
public static final double E = 2.718281828459045;
public static final double GOLDEN = 1.618033988749895;
public static final int PRIMES[] = {2, 3, 5, 7, 11, 13};
}
// Access without an instance
System.out.println(MathConstants.PI);
// Constants on domain classes
class HttpStatus {
public static final int OK = 200;
public static final int NOT_FOUND = 404;
public static final int SERVER_ERR = 500;
}Statische Initialisierungsblöcke
Wenn eine Konstante eine komplexe Initialisierung erfordert, verwenden Sie einen statischen Initialisierungsblock, der einmal beim Laden der Klasse ausgeführt wird.
import java.util.*;
class Config {
public static final Map<String, String> DEFAULTS;
static {
Map<String, String> map = new HashMap<>();
map.put("timeout", "30");
map.put("maxRetry", "3");
map.put("logLevel", "INFO");
DEFAULTS = Collections.unmodifiableMap(map);
}
}
System.out.println(Config.DEFAULTS.get("timeout")); // 30Muster für statische Zähler
Statische Felder werden häufig zur ID-Generierung, zum Zählen von Metriken oder für gemeinsam genutzte Caches verwendet.
import java.util.concurrent.atomic.AtomicLong;
class Order {
private static final AtomicLong ID_SEQUENCE = new AtomicLong(1000);
private final long id;
private final String item;
Order(String item) {
this.id = ID_SEQUENCE.getAndIncrement();
this.item = item;
}
long getId() { return id; }
String getItem() { return item; }
}
Order o1 = new Order("Laptop");
Order o2 = new Order("Mouse");
System.out.println(o1.getId()); // 1000
System.out.println(o2.getId()); // 1001Singleton über ein statisches Feld
In einem Singleton enthält ein statisches Feld die einzige Instanz. Verwenden Sie eine verzögerte Initialisierung für Klassen, die möglicherweise nicht immer benötigt werden.
class DatabasePool {
private static volatile DatabasePool instance;
private final int maxConnections;
private DatabasePool() { this.maxConnections = 20; }
public static DatabasePool getInstance() {
if (instance == null) {
synchronized (DatabasePool.class) {
if (instance == null)
instance = new DatabasePool();
}
}
return instance;
}
public int getMaxConnections() { return maxConnections; }
}
System.out.println(DatabasePool.getInstance().getMaxConnections()); // 20Statischer Import
import static ermöglicht die Verwendung statischer Member ohne das Präfix des Klassennamens – nützlich für Konstanten und Hilfsmethoden.
import static java.lang.Math.PI;
import static java.lang.Math.sqrt;
import static java.lang.Math.pow;
// Without import static: Math.PI * Math.pow(r, 2)
double radius = 5.0;
double area = PI * pow(radius, 2);
System.out.printf("Area: %.2f%n", area); // 78.54
// Caution: overuse of static imports hurts readability
// Acceptable for: Math.*, Assert.* in tests, TimeUnitThread-Sicherheit statischer Felder
Statische Felder, die von mehreren Threads gemeinsam genutzt werden, erfordern eine Synchronisierung oder atomare Typen, um Race Conditions zu vermeiden.
import java.util.concurrent.atomic.*;
class RequestMetrics {
private static final AtomicLong requestCount = new AtomicLong(0);
private static final AtomicLong totalLatencyMs = new AtomicLong(0);
public static void record(long latencyMs) {
requestCount.incrementAndGet();
totalLatencyMs.addAndGet(latencyMs);
}
public static double averageLatency() {
long count = requestCount.get();
return count == 0 ? 0 : (double) totalLatencyMs.get() / count;
}
}
RequestMetrics.record(45);
RequestMetrics.record(120);
System.out.println(RequestMetrics.averageLatency()); // 82.5Veränderliche statische Felder: Fallstricke
Veränderliche statische Felder sind gefährlich: Ein globaler veränderlicher Zustand ist schwer zu testen, ohne entsprechende Maßnahmen nicht threadsicher und erzeugt eine versteckte Kopplung zwischen Klassen.
// BAD: mutable static state
class GlobalConfig {
public static String environment = "dev"; // mutable global!
}
// Any code anywhere can change GlobalConfig.environment
// Very hard to test, unexpected interactions
// BETTER: immutable constant
class GlobalConfig2 {
public static final String ENVIRONMENT =
System.getenv().getOrDefault("APP_ENV", "dev");
}
// BEST: inject via constructor (dependency injection)
class Service {
private final String environment;
Service(String environment) { this.environment = environment; }
}Anti-Pattern: Konstanten-Interface
Es wird davon abgeraten, ein Interface für Konstanten zu verwenden (das Anti-Pattern "Constant Interface"). Verwenden Sie stattdessen eine Klasse mit privatem Konstruktor.
// BAD: constant interface — pollutes the namespace of implementing classes
interface FinancialConstants {
double TAX_RATE = 0.08; // implicitly public static final
}
// GOOD: utility class for constants
final class FinancialConstants2 {
private FinancialConstants2() {} // prevent instantiation
public static final double TAX_RATE = 0.08;
public static final double VAT_RATE = 0.20;
public static final int MAX_ITEMS = 100;
}
System.out.println(FinancialConstants2.TAX_RATE); // 0.08Praxis: Feature-Flags über Konstanten
Verwendung von static final boolean-Konstanten als Feature-Flags zur Kompilierzeit – der JIT-Compiler entfernt tote Zweige.
class Features {
public static final boolean ENABLE_ANALYTICS = true;
public static final boolean ENABLE_AI_SEARCH = false;
public static final boolean DEBUG_MODE =
"true".equals(System.getenv("DEBUG"));
}
// The JIT eliminates this if-block when ENABLE_AI_SEARCH is false:
if (Features.ENABLE_AI_SEARCH) {
System.out.println("Running AI search...");
}
if (Features.DEBUG_MODE) {
System.out.println("[DEBUG] Request received");
}Schnelltest
Was ist der Unterschied zwischen einem statischen Feld und einem Instanzfeld?
Zusammenfassung: Statische Felder und Konstanten
Die wichtigsten Erkenntnisse:
- Statische Felder gehören zur Klasse – eine Kopie, die von allen Instanzen gemeinsam genutzt wird
- Konstanten: public static final UPPER_SNAKE_CASE
- Verwenden Sie statische Initialisierungsblöcke für Konstanten, die eine komplexe Initialisierung erfordern
- Bevorzugen Sie AtomicLong/AtomicInteger für veränderliche statische Felder in nebenläufigem Code
- Vermeiden Sie veränderliche statische Felder – sie erzeugen einen versteckten globalen Zustand, der schwer zu testen ist
- Verwenden Sie für Konstanten eine nicht instanziierbare Klasse (privater Konstruktor) statt eines Interfaces
Häufig gestellte Fragen
Ist die Lektion „Statische Felder und Konstanten“ kostenlos?
Ja — der vollständige Text von „Statische Felder und Konstanten“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Statische Felder und Konstanten“?
Verwenden Sie statische Felder für gemeinsam genutzten Zustand, Konstanten mit static final und statische Initialisierer. Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Java Academy zu starten?
Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.
Wie lange dauert die Lektion „Statische Felder und Konstanten“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?
Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Regeln für Methodenüberladung
- Varargs-Parameter
- Statische Felder und Konstanten
- Utility-Klassen und statische Factory-Methoden