> ## 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 Constructor A constructor in Dart is a special function invoked during the instantiation of a class, strictly responsible for initializing the newly created object's state. Memory allocation is handled by the Dart runtime prior to the constructor's execution. Unlike regular methods, constructors share the same name as the class (or a specific named variant) and do not declare a return type. If no constructor is explicitly declared, Dart implicitly provides a default, no-argument generative constructor. A fundamental rule in Dart is that **constructors are not inherited**; subclasses do not inherit generative or named constructors from their superclass. ## Generative Constructors and Initializing Formal Parameters The most common type of constructor is the generative constructor. Dart provides syntactic sugar called **initializing formal parameters** (`this.propertyName`) to assign arguments directly to instance variables before the constructor body executes. ```dart theme={"dark"} class Point { double x; double y; // Generative constructor using initializing formal parameters Point(this.x, this.y); } ``` ## Named Constructors Dart does not support constructor overloading (multiple constructors with the same name but different signatures). Instead, Dart utilizes **named constructors** to allow multiple instantiation patterns for a single class. ```dart theme={"dark"} class Point { double x; double y; Point(this.x, this.y); // Named constructor syntax: ClassName.identifier Point.origin() : x = 0, y = 0; } ``` ## Initializer Lists An initializer list executes after arguments are evaluated but immediately before the constructor body runs. It is separated from the constructor signature by a colon (`:`). It is commonly used to initialize `final` fields that are not initialized at their declaration site or via formal parameters (though `late final` fields can be initialized inside the constructor body). It is also required when passing arguments to a superclass constructor or invoking a named superclass constructor; otherwise, Dart implicitly calls the superclass's default, no-argument constructor. Initializer lists are also used to enforce `assert` statements during development. ```dart theme={"dark"} class Vector { final double x; final double y; final double squaredMagnitude; // Initializer list evaluating an expression before instantiation completes Vector(this.x, this.y) : squaredMagnitude = (x * x + y * y); } ``` ## Redirecting Constructors A constructor can delegate initialization to another constructor within the same class. This is done using a colon followed by `this(...)`. A redirecting constructor cannot have a body. ```dart theme={"dark"} class Point { double x; double y; Point(this.x, this.y); // Redirects to the main generative constructor Point.alongXAxis(double x) : this(x, 0); } ``` ## Constant Constructors If an object's state must remain immutable and can be determined at compile time, Dart uses **constant constructors**. The class must declare all instance variables as `final`, and the constructor is prefixed with the `const` keyword. Invoking it with `const` yields a compile-time constant, canonicalized instance. ```dart theme={"dark"} class ImmutablePoint { final double x; final double y; // Constant constructor const ImmutablePoint(this.x, this.y); } ``` ## Factory Constructors A `factory` constructor does not implicitly allocate a new instance of its class. Instead, it acts as a static method that must explicitly return an instance of the class or a subtype. Because it does not generate an instance directly, a factory constructor does not have access to the `this` reference. ```dart theme={"dark"} class Logger { final String name; static final Map _cache = {}; // Factory constructor returning a cached instance factory Logger(String name) { return _cache.putIfAbsent(name, () => Logger._internal(name)); } // Private generative constructor Logger._internal(this.name); } ``` ## Super Parameters Introduced in Dart 2.17, **super parameters** provide a concise syntax to pass arguments directly to the superclass constructor without explicitly invoking `super(...)` in the initializer list. ```dart theme={"dark"} class Point { final double x; final double y; Point(this.x, this.y); } class Point3D extends Point { final double z; // super.x and super.y are forwarded to the Point constructor Point3D(super.x, super.y, this.z); } ```
Tired of Poor Dart Skills? Fix That With Deep Grasping! Learn More