> ## 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 Public Field
A public field in Dart is a class-level variable that is accessible from any library that imports the class. Unlike languages that rely on explicit access modifier keywords (such as `public`, `private`, or `protected`), Dart determines visibility through lexical naming conventions. Any field whose identifier does not begin with an underscore (`_`) is implicitly public.
## Syntax and Declaration
Public fields can be mutable variables, immutable variables (`final`), or class-level variables (`static`). Because Dart does not use a `public` keyword, the declaration relies solely on the type, the identifier, and optional modifiers.
```dart theme={"dark"}
class Configuration {
// Public mutable instance field
String environment;
// Public immutable instance field (can only be set once)
final String version;
// Public static field (belongs to the class, not instances)
static int maxConnections = 100;
// Public late-initialized field
late String databaseUrl;
Configuration(this.environment, this.version);
}
```
## Technical Characteristics
**Implicit Accessors**
When you declare a public field, the Dart compiler automatically generates implicit accessor methods.
* For a mutable public field (e.g., `String environment`), Dart generates both an implicit getter and an implicit setter.
* For an immutable public field (e.g., `final String version`), Dart generates only an implicit getter.
When a developer uses dot notation (`object.field`), they are technically invoking these implicit methods rather than accessing the memory location directly. This allows you to later replace a public field with explicit getter/setter methods without breaking the API or requiring changes to the calling code.
**Library-Level Scoping**
Dart's visibility model is based on library boundaries, not class boundaries. Because a public field lacks the `_` prefix, it is exported as part of the library's public API. Any external Dart file that imports the library can read (and, if mutable, write to) the field.
**Null Safety Enforcement**
Under Dart's sound null safety, public fields must be guaranteed to have a value before they are accessed. A public field must be:
1. Initialized at the point of declaration.
2. Initialized in the constructor (via initializing formals or an initializer list).
3. Declared as nullable using the `?` operator (e.g., `String? name`).
4. Marked with the `late` keyword, deferring the initialization check to runtime.
## Access Mechanics
Accessing public fields is done using standard dot notation. Instance fields require an instantiated object, while static fields are accessed directly on the class type.
```dart theme={"dark"}
void main() {
var config = Configuration('Production', '1.0.0');
// Invoking the implicit setter
config.environment = 'Staging';
// Invoking the implicit getter
print(config.version);
// Accessing a public static field via the class type
print(Configuration.maxConnections);
}
```
Tired of Poor Dart Skills? Fix That With Deep Grasping!
Learn More
