> ## 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 Final Class
An `abstract final` class in Dart is a class modifier combination that establishes a strictly closed type hierarchy. It prevents the class from being instantiated globally, while simultaneously restricting inheritance (`extends`) and implementation (`implements`) exclusively to the library in which it is defined.
## Technical Mechanics
The behavior of this construct is the exact intersection of its two modifiers:
* **`abstract`**: Instructs the compiler to prohibit direct instantiation of the class. It permits the declaration of abstract members (methods, getters, setters) that lack an implementation, forcing valid subclasses to provide them.
* **`final`**: Instructs the compiler to close the class to external derivation. No class outside of the defining library's URI can use the class in an `extends` or `implements` clause. (Note: An `abstract final` class can never be used in a `with` clause, as Dart does not permit the `final` modifier on mixins or mixin classes).
## Syntax and Scope Rules
**Within the defining library (`base_library.dart`):**
```dart theme={"dark"}
// base_library.dart
abstract final class CoreComponent {
// Abstract member declaration allowed
void initialize();
// Concrete member allowed
void dispose() {
print('Disposed');
}
}
// ALLOWED: Extending within the same library.
// Subtypes must be marked base, final, or sealed.
final class NetworkComponent extends CoreComponent {
@override
void initialize() => print('Network ready');
}
// ALLOWED: Implementing within the same library.
// Subtypes must be marked base, final, or sealed.
base class UIComponent implements CoreComponent {
@override
void initialize() => print('UI ready');
@override
void dispose() => print('UI disposed');
}
```
**Outside the defining library (`external_library.dart`):**
```dart theme={"dark"}
// external_library.dart
import 'base_library.dart';
void main() {
// ERROR: Abstract classes cannot be instantiated.
// CoreComponent component = CoreComponent();
}
// ERROR: The class 'CoreComponent' can't be extended outside of its library because it's a final class.
final class CustomComponent extends CoreComponent {
@override
void initialize() {}
}
// ERROR: The class 'CoreComponent' can't be implemented outside of its library because it's a final class.
base class MockComponent implements CoreComponent {
@override
void initialize() {}
@override
void dispose() {}
}
```
## Compiler Characteristics
* **Constructors:** An `abstract final` class can declare generative constructors. However, because the class cannot be instantiated directly, these constructors can only be invoked via `super()` calls from subclasses defined within the exact same library.
* **Exhaustiveness Checking:** Unlike `sealed` classes (which are implicitly abstract and share the same library-restriction rules), `abstract final` classes **do not** trigger exhaustiveness checking in `switch` statements or expressions. The compiler will not enforce that all subtypes are handled when switching over an `abstract final` type.
* **Subtype Modifiers:** Subclasses of an `abstract final` class within the same library must explicitly declare their own modifiers (`base`, `final`, or `sealed`) to maintain the integrity of the restricted hierarchy.
Tired of Poor Dart Skills? Fix That With Deep Grasping!
Learn More
