> ## 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 Named Constructor
A named constructor is an explicitly identified constructor that allows a class to define multiple instantiation paths. Because Dart does not support constructor overloading by parameter signature, named constructors provide the mechanism to declare multiple constructors within a single class while explicitly defining the initialization behavior.
## Syntax
A named constructor is defined by appending a dot (`.`) and an identifier to the class name.
```dart theme={"dark"}
class ClassName {
// Unnamed constructor
ClassName() {
// ...
}
// Named constructor
ClassName.identifier(parameters) {
// Initialization logic
}
// Private named constructor
ClassName._privateIdentifier(parameters) {
// Initialization logic
}
}
```
## Technical Characteristics
**1. No Inheritance**
Named constructors are not inherited by subclasses. If a subclass needs to be instantiated using a named constructor defined in its superclass, the subclass must explicitly declare its own constructor (named or unnamed) and invoke the superclass's named constructor via the initializer list.
**2. Constructor Redirection**
A named constructor can delegate initialization to another constructor within the same class using the `this` keyword in the initializer list. When redirecting, the constructor body must remain empty.
**3. Superclass Invocation**
A named constructor can invoke a specific named constructor of its superclass using the `super.identifier()` syntax within the initializer list. This invocation must occur before any local constructor body executes.
**4. Factory Modifiers**
Named constructors can be declared with the `factory` keyword. A factory named constructor does not strictly allocate a new instance; it can return an existing instance from a cache or return an instance of a subtype.
**5. Private Named Constructors**
By prefixing the named constructor's identifier with an underscore (`_`), the constructor becomes private to its declaring library. This is a structural pattern used to restrict external instantiation, force the use of factory constructors, or implement singletons.
## Implementation Mechanics
The following code demonstrates the structural mechanics of named constructors, including standard initialization, redirection, superclass delegation, and private access control.
```dart theme={"dark"}
class Point {
double x;
double y;
// Standard generative unnamed constructor
Point(this.x, this.y);
// Named constructor using an initializer list
Point.origin()
: x = 0.0,
y = 0.0;
// Named constructor redirecting to the standard constructor
Point.alongXAxis(double x) : this(x, 0.0);
// Private named constructor restricting external access
Point._internal(this.x, this.y);
}
class Point3D extends Point {
double z;
// Subclass named constructor delegating to a superclass named constructor
Point3D.origin()
: z = 0.0,
super.origin();
}
void main() {
// Instantiation via named constructors
final p1 = Point.origin();
final p2 = Point.alongXAxis(5.0);
final p3 = Point3D.origin();
// Point._internal(1.0, 1.0); // Compilation error if called outside the library
}
```
Tired of Poor Dart Skills? Fix That With Deep Grasping!
Learn More
