> ## 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 Abstract Setter
An abstract setter in Dart is a mutator method declared without an implementation body within an abstract class. It establishes a strict structural contract, compelling any concrete subclass to provide the implementation logic for assigning a value to a specific property identifier.
## Syntax
An abstract setter is defined using the `set` keyword followed by the property name and a single parameter, terminated by a semicolon rather than a method body.
```dart theme={"dark"}
abstract class AbstractClass {
set propertyName(Type value);
}
```
## Implementation Mechanics
When a concrete class inherits or implements an abstract class containing an abstract setter, it must satisfy the contract. Dart allows this contract to be fulfilled in two distinct ways:
1. **Explicit Setter:** Defining a concrete mutator method using the `set` keyword.
2. **Implicit Setter:** Declaring a non-final, mutable instance variable of the exact same name and type. Dart automatically generates an implicit setter for mutable fields, which satisfies the abstract contract.
```dart theme={"dark"}
abstract class Configuration {
// Abstract setter declaration
set threshold(double value);
}
// Fulfillment via Explicit Setter
class StrictConfiguration extends Configuration {
double _internalThreshold = 0.0;
@override
set threshold(double value) {
_internalThreshold = value;
}
}
// Fulfillment via Implicit Setter (Mutable Field)
class DefaultConfiguration extends Configuration {
@override
double threshold = 10.5;
}
```
## Technical Constraints and Rules
* **Parameter Type Compatibility (Contravariance):** The parameter type of the overriding setter must be the same type or a supertype of the parameter type defined in the abstract setter. Dart allows widening the parameter type (e.g., overriding `set threshold(double value)` with `set threshold(num value)`).
* **Covariance:** If a subclass needs to narrow the parameter type (restricting the setter to accept only a subtype), the `covariant` keyword must be applied to the parameter in either the abstract declaration or the concrete implementation to bypass static type checking errors.
* **Return Type:** Setters in Dart inherently return `void`. While explicitly declaring `void` before the `set` keyword is syntactically valid (`void set propertyName(Type value);`), it is redundant and generally omitted in idiomatic Dart.
* **Independence:** An abstract setter is an independent method signature. It does not require a corresponding abstract getter, though they are frequently declared together to define a fully mutable abstract property.
Tired of Poor Dart Skills? Fix That With Deep Grasping!
Learn More
