In Dart 3, what do `abstract interface class` and `abstract final class` declare, and which class modifier combinations does the compiler reject?

## The grammar of class modifiers A Dart 3 class declaration can carry several modifiers, but only in one order (dart.dev, "Combining modifiers"): 1. optional **`abstract`** — may have abstract members, cannot be constructed; 2. optional, **at most one** of **`base`**, **`interface`**, **`final`**, **`sealed`** — restrictions on other libraries; 3. optional **`mixin`** — can be mixed in; 4. the **`class`** keyword. Only `base` may precede a `mixin` declaration (`base mixin`). The modifiers do not apply to `enum`, `typedef`, `extension` or `extension type` declarations. ## `abstract interface class`: the pure interface Dart has no separate `interface` keyword for declaring contracts; every class exposes an implicit interface. Before Dart 3, a reader could not tell whether an abstract class was meant for extending or implementing. `abstract interface class` settles it: ```dart abstract interface class PaymentGateway { Future<void> charge(int cents); } ``` - other libraries may **implement** it; - they may **not extend** it, so they cannot inherit code from it; - nobody can **construct** it, because it is abstract. dart.dev calls this the most common use of `interface`. `dart:core` itself declares `List`, `Map`, `Comparable` and `Exception` as `abstract interface class`. ## `abstract final class`: closed and non-instantiable `abstract final class` cannot be instantiated directly anywhere (like any abstract class, it may still expose factory constructors), and it cannot be extended, implemented or mixed in outside its library. Two uses: - **A namespace for static members**, such as payment limits or currency constants, that nobody should instantiate or subtype: ```dart abstract final class PaymentLimits { static const int maxCents = 1000000; static const int minCents = 50; } ``` - **A closed type whose instances come only from the declaring library**, which is how `dart:core` declares `String`, `int`, `double` and `BigInt`: you can use them, but you cannot implement `String` yourself. ## Combinations the compiler rejects | Combination | Why it is invalid | |---|---| | two or more of `base`, `interface`, `final` | they control the same two capabilities, so they are mutually exclusive | | `sealed` with `abstract` | `sealed` is already implicitly abstract (analyzer: `abstract_sealed_class`) | | `sealed` with `base`, `interface` or `final` | `sealed` already blocks every outside subtyping, so they are redundant | | `mixin` with `interface`, `final` or `sealed` | those modifiers prevent mixing in, which `mixin` exists for | | any modifier on `enum` | enums are never extended, implemented or mixed in | | any modifier on `extension type` | extension types are only implemented by other extension types | ## Valid combinations worth knowing - `abstract base class` — can be extended, not implemented, not constructed. - `abstract interface class` — the pure interface above. - `abstract final class` — static holders and closed types. - `base mixin class`, `abstract mixin class`, `abstract base mixin class` — mixin classes with restrictions (mixins are covered in their own topic). - `sealed class` — alone; never with another access modifier. ## Reading declarations in an interview Interviewers often show a declaration and ask what outside code can do. Work left to right: 1. `abstract` or `sealed` present? Then no one can construct it. 2. Which access modifier? `base` keeps extend, `interface` keeps implement, `final` and `sealed` keep neither. 3. `mixin` present? Then it can also appear after `with`, unless `base` limits implementers. ## Version note All modifiers other than `abstract` need a library language version of 3.0 or later. Applying them to a published API is a breaking change and calls for a major version.