Dart Static Field - SyntBlaze

A static field in Dart is a class-level variable that belongs to the class itself rather than to any specific instance of that class. It shares a single memory allocation across the entire application lifecycle, meaning all instances of the class, as well as the broader application, access the exact same underlying reference and value.

Syntax and Declaration

Static fields are declared using the static keyword preceding the type annotation. They can be mutable, or they can be combined with final or const to enforce immutability.

class NetworkConfig {
  // Mutable static field
  static int timeoutSeconds = 30;

  // Run-time constant static field (evaluated once at runtime)
  static final DateTime initializationTime = DateTime.now();

  // Compile-time constant static field
  static const String protocol = "HTTPS";
}

Access Mechanism

Static fields are resolved statically at compile time. They must be accessed directly through the class identifier. Dart strictly prohibits accessing static members through an instance reference; attempting to do so results in a compile-time error.

// Correct: Accessed via the class name
int currentTimeout = NetworkConfig.timeoutSeconds;
NetworkConfig.timeoutSeconds = 60;

// Incorrect: Compile-time error
NetworkConfig config = NetworkConfig();
// int timeout = config.timeoutSeconds; // Error: The getter 'timeoutSeconds' isn't defined...

Lazy Initialization

Dart employs a lazy initialization model for static fields. The expression assigned to a static field is not evaluated, and memory is not allocated, until the exact moment the field is first accessed during runtime. This behavior applies to both mutable static fields and static final fields, ensuring that computationally expensive initializations are deferred until strictly necessary.

Interaction with `const`

In Dart, if you want to declare a compile-time constant at the class level, it must be explicitly marked as static const. A class cannot have an instance-level const field because instance state is inherently evaluated at runtime during object instantiation.

class MathConstants {
  // Valid
  static const double pi = 3.14159;
  
  // Invalid: Only static fields can be declared as const.
  // const double e = 2.71828; 
}