Dart Super Initializer

A super-initializer parameter (often referred to as a super parameter) is a syntactic feature in Dart that allows a subclass constructor to forward arguments directly to a superclass constructor without explicitly passing them through the initializer list. By applying the super. prefix to a parameter in the subclass constructor signature, the Dart compiler automatically binds and routes that argument to the corresponding parameter in the superclass.

Syntax Comparison

Prior to the introduction of super initializers, forwarding parameters required declaring the parameter in the subclass and explicitly passing it via the initializer list:

class Base {
  final int id;
  Base(this.id);
}

// Legacy approach
class Derived extends Base {
  final String name;
  
  Derived(int id, this.name) : super(id); 
}

Using a super initializer, the parameter is forwarded inline directly from the constructor signature:

// Modern approach using super parameters
class Derived extends Base {
  final String name;
  
  Derived(super.id, this.name); 
}

Parameter Resolution Mechanics

The compiler resolves super. parameters differently depending on whether they are positional or named. 1. Positional Parameters When super. is applied to positional parameters, the Dart compiler maps them to the superclass constructor’s positional parameters based strictly on their declaration order.

class Point2D {
  final double x;
  final double y;
  Point2D(this.x, this.y);
}

class Point3D extends Point2D {
  final double z;
  
  // super.x maps to the first positional parameter (x)
  // super.y maps to the second positional parameter (y)
  Point3D(super.x, super.y, this.z); 
}

2. Named Parameters When super. is applied to named parameters, the compiler maps them to the superclass constructor’s named parameters by matching the exact identifier. Declaration order is irrelevant.

class Configuration {
  final bool isDebug;
  final String environment;
  
  Configuration({required this.isDebug, this.environment = 'prod'});
}

class AppConfig extends Configuration {
  final int port;
  
  // Maps directly to 'isDebug' and 'environment' in the superclass
  AppConfig({
    required this.port,
    required super.isDebug,
    super.environment,
  });
}

Technical Constraints and Behavior

Type Inference: The type of a super. parameter is implicitly inferred from the corresponding parameter in the superclass constructor. Explicitly declaring the type (e.g., int super.id) is redundant unless you are intentionally restricting the parameter to a stricter subtype.
Interaction with Explicit Super Invocations: Super parameters can be combined with an explicit super constructor call (e.g., : super.named(...)) in the initializer list, but strict rules apply to prevent argument duplication or ambiguity:
- Positional Parameters: If a constructor uses positional super parameters, the explicit super constructor invocation cannot contain any positional arguments. It is a compile-time error to mix positional super parameters with explicitly passed positional arguments in the super(...) call.
- Named Parameters: Named super parameters can be used alongside an explicit super call, provided the explicit call only provides other named arguments. You cannot pass a named argument in the super(...) call if a super. parameter is already forwarding it.

class Base {
  final int x;
  final int y;
  final String label;
  
  Base.custom(this.x, this.y, {required this.label});
}

class Derived extends Base {
  // Valid: Positional super parameters map to x and y.
  // The explicit super call provides the named argument 'label'.
  // No positional arguments are passed in super.custom(...).
  Derived(super.x, super.y) : super.custom(label: 'Default'); 
}

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

Dart Super Initializer

Syntax Comparison

Parameter Resolution Mechanics

Technical Constraints and Behavior

​Syntax Comparison

​Parameter Resolution Mechanics

​Technical Constraints and Behavior

Syntax Comparison

Parameter Resolution Mechanics

Technical Constraints and Behavior