Dart Abstract Interface Class

​

Core Mechanics

• Instantiation: Direct instantiation using generative constructors is prohibited globally. However, the class can define and be invoked via factory constructors that return instances of concrete subtypes (similar to Dart’s built-in List).
• Implementation (implements): Permitted globally. Any class, regardless of the library it resides in, can implement the class’s interface.
• Inheritance (extends): Permitted only within the same defining library. External libraries are blocked from extending the class.
• Member Definitions: Can contain both abstract members (without bodies) and concrete members (with bodies).

​

Syntax and Cross-Library Behavior

abstract interface class DataRepository {
  // Explicit generative constructor required for subclasses to extend
  // because declaring a factory constructor prevents implicit generation.
  DataRepository(); 

  // ALLOWED: Factory constructors can instantiate and return concrete subtypes.
  factory DataRepository.local() = LocalRepository;

  // Abstract method
  void fetch(); 

  // Concrete method
  void dispose() {
    print('Disposing resources');
  }
}

// ALLOWED: Extending is permitted within the same library.
// Inherits the concrete implementation of dispose().
class LocalRepository extends DataRepository {
  @override
  void fetch() => print('Fetching locally');
}

import 'library_a.dart';

void main() {
  // ERROR: Cannot be instantiated via a generative constructor.
  // DataRepository repo = DataRepository();
  
  // ALLOWED: Instantiation via a factory constructor.
  DataRepository repo = DataRepository.local();
}

// ERROR: The 'interface' modifier prevents extension outside the defining library.
// class RemoteRepository extends DataRepository {}

// ALLOWED: External classes must use 'implements'.
class CloudRepository implements DataRepository {
  @override
  void fetch() {
    print('Fetching from cloud');
  }

  // REQUIRED: 'implements' only inherits member signatures.
  // The concrete dispose() behavior from DataRepository is not inherited.
  // It must be explicitly overridden.
  @override
  void dispose() {
    print('Disposing cloud resources');
  }
}

​

Technical Characteristics

1. Interface-Only Inheritance: When an external class uses the implements keyword on an abstract interface class, the implements keyword tells Dart to inherit only the class’s interface (its member signatures). The implementing class does not inherit any concrete behavior defined in the base class and must provide its own implementation for every member (methods, getters, setters).
2. Library Encapsulation: In Dart, a library is typically a single .dart file (along with any files included via part directives). The extends restriction of the interface modifier is enforced exactly at this boundary.
3. Pattern Matching Exhaustiveness: Unlike sealed classes, an abstract interface class does not provide exhaustiveness checking for the compiler. A switch statement evaluating subtypes of an abstract interface class will require a default case or wildcard, as the compiler cannot guarantee all possible implementations are known.