> ## 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 Getter
A public getter in Dart is a specialized method that provides read access to an object's state or computed properties using field-access syntax. In Dart, identifiers are public by default; therefore, a getter is public as long as its name does not begin with an underscore (`_`).
## Implicit Public Getters
When you declare a public instance variable, Dart automatically generates an implicit public getter for it.
```dart theme={"dark"}
class User {
String username = 'admin'; // Implicit public getter generated
}
void main() {
final user = User();
print(user.username); // Invokes the implicit getter
}
```
## Explicit Public Getters
Explicit public getters are defined using the `get` keyword. They allow you to define custom logic for property retrieval, such as computing a value dynamically or exposing a private field, while maintaining the syntactic footprint of a standard field access.
### Syntax
An explicit getter is declared with an optional return type, the `get` keyword, and the identifier, followed by either a block body or an arrow function. It strictly takes no parameters and omits the parameter list parentheses `()`.
**Arrow Syntax:**
```dart theme={"dark"}
ReturnType get propertyName => expression;
```
**Block Body Syntax:**
```dart theme={"dark"}
ReturnType get propertyName {
// computation
return value;
}
```
### Code Example
```dart theme={"dark"}
class Rectangle {
double width;
double height;
// Private variable
final double _borderWidth = 2.0;
Rectangle(this.width, this.height);
// Explicit public getter (Computed property)
double get area => width * height;
// Explicit public getter (Exposing private state)
double get border => _borderWidth;
}
void main() {
final rect = Rectangle(10.0, 5.0);
// Accessed without parentheses, identical to field access
print(rect.area);
print(rect.border);
}
```
## Technical Characteristics
* **Parameterless:** A getter cannot define any parameters. Attempting to add parentheses `()` to a getter declaration results in a compilation error.
* **Uniform Access Principle:** Because both implicit and explicit getters are invoked using dot notation (`object.property`), you can change a standard public field into an explicit getter later without breaking the API or requiring changes to the calling code.
* **Scope:** Public getters can be declared at the top level of a library, or within classes, mixins, enums, and extensions.
* **Read-Only Enforcement:** Defining an explicit getter without a corresponding explicit setter (`set`) creates a read-only property from the perspective of the caller. Attempting to assign a value to it will result in a compilation error.
* **Overriding:** Explicit getters can override implicit getters (fields) from a superclass, and vice versa.
Tired of Poor Dart Skills? Fix That With Deep Grasping!
Learn More
