> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Dart Static Field
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.
```dart theme={"dark"}
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.
```dart theme={"dark"}
// 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.
```dart theme={"dark"}
class MathConstants {
// Valid
static const double pi = 3.14159;
// Invalid: Only static fields can be declared as const.
// const double e = 2.71828;
}
```
Tired of Poor Dart Skills? Fix That With Deep Grasping!
Learn More
