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:

Extension is permitted: External classes can use the extends keyword to inherit from the base class.
Implementation is prohibited externally: Classes outside of the defining library cannot use the implements keyword to treat the base class as an interface.
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.

// 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() {}
}

// 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.

abstract base class DataProcessor {
  // Abstract method requiring implementation in subclasses
  void process(List<int> 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<int> 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 ==.

// This declaration:
class Entity {}

// Is semantically equivalent to:
class Entity extends Object {}

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

Methods

Constructors

Classes

Getters & Setters

Variables

Fields

Parameters

Pattern Matching

Generics

Extensions

Type Aliases

Enums

Control Flow

Loops

Error Handling

Standard Library Types

Annotations

Libraries & Imports

Built-In Types

Comments

Cascade Operators

Spread Operators

Access Operators

Type Cast & Test Operators

Conditional Operators

Arithmetic Operators

Comparison Operators

Logical Operators

Increment & Decrement Operators

Unary Operators

Bitwise Operators

Assignment Operators

The `base` Modifier Mechanics

Abstract Base Classes

The Implicit Base Class: `Object`

​The base Modifier Mechanics

​Abstract Base Classes

​The Implicit Base Class: Object

The `base` Modifier Mechanics

Abstract Base Classes

The Implicit Base Class: `Object`