> ## 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 Base Class A base class in Dart is a class that establishes an inheritance hierarchy by allowing other classes to inherit its properties and methods. In Dart 3 and later, `base` is a specific class modifier that restricts how a class can be consumed across library boundaries, explicitly permitting inheritance (`extends`) while strictly prohibiting interface implementation (`implements`). ## The `base` Modifier Mechanics When a class is declared with the `base` modifier, Dart enforces the following compiler-level guarantees: 1. **Extension is permitted:** External classes can use the `extends` keyword to inherit from the base class. 2. **Implementation is prohibited externally:** Classes outside of the defining library cannot use the `implements` keyword to treat the base class as an interface. 3. **Modifier propagation:** Any class that extends *or implements* a `base` class must be marked as `base`, `final`, or `sealed`. While implementing a `base` class is prohibited externally, it is perfectly valid within the same library. Enforcing the modifier on implementing classes ensures that external libraries cannot bypass the `base` restriction by implementing a subtype. ```dart theme={"dark"} // library_a.dart base class CoreSystem { int systemId; CoreSystem(this.systemId); void initialize() { print('System $systemId initialized'); } } // VALID: Implementing a base class is allowed WITHIN the same library. // The implementing class MUST propagate the restriction (base, final, or sealed). final class InternalMockSystem implements CoreSystem { @override int systemId; InternalMockSystem(this.systemId); @override void initialize() {} } ``` ```dart theme={"dark"} // library_b.dart import 'library_a.dart'; // VALID: Extending a base class is allowed outside its library. // The subclass MUST propagate the restriction (base, final, or sealed). base class SubSystem extends CoreSystem { SubSystem(super.systemId); } // INVALID: Implementing a base class outside its library causes a compile-time error. class ExternalMockSystem implements CoreSystem { // Compile error: The class 'CoreSystem' can't be implemented outside of its library // because it's a base class. } ``` ## Abstract Base Classes The `base` modifier can be combined with the `abstract` modifier. An `abstract base` class cannot be instantiated directly and forces subclasses to provide implementations for its abstract members, while still preventing external libraries from using it as an interface. ```dart theme={"dark"} abstract base class DataProcessor { // Abstract method requiring implementation in subclasses void process(List data); // Concrete method inherited by subclasses void log(String message) { print(message); } } // Subclasses must implement process() and must declare a valid modifier final class ImageProcessor extends DataProcessor { @override void process(List data) { // Implementation details } } ``` ## The Implicit Base Class: `Object` In the Dart type system, if a class does not explicitly extend another class, it implicitly extends `Object`. Therefore, `Object` serves as the ultimate base class for the entire Dart class hierarchy (with the exception of `Null`), providing foundational methods such as `toString()`, `hashCode`, and `operator ==`. ```dart theme={"dark"} // This declaration: class Entity {} // Is semantically equivalent to: class Entity extends Object {} ```

Tired of Poor Dart Skills? Fix That With Deep Grasping! Learn More