Dart/Flutter: Multiple constructor overloading examples
In java, multiple constructors can be defined and overloaded. Constructors are used to initializing the fields of a class during object creation.
Dart does not support an overload of functions and constructors and does not allow multiple functions/constructors of the same name with different arguments.
A Dart class can have only one Default or unnamed constructor. Default constructor syntax:
class Classname{
fields
// default one construcotr
Classname(fields)
}
default constructor Example
class Employee {
final int id;
final String name;
// Default or unnamed constructor
Employee(this.id, this.name);
}
if you declare or overload multiple constructors as given below
class Employee {
final int id;
final String name;
// Default or unnamed constructor
Employee(this.id, this.name);
Employee(this.id);
}
void main() {
print("getEnumNames(WEEK.values)");
}
It gives a compilation error
Error: ‘Employee’ is already declared in this scope. Employee(this.id); ^^^^^^^^ lib/main.dart:6:3: Info: Previous declaration of ‘Employee’. Employee(this.id, this.name); ^^^^^^^^ Then, How do implement multiple constructors in Dart?
named constructor is the way to implement multiple constructors apart from the default constructor Dart supports the constructor in two ways.
- default and unnamed constructor: Allows only one constructor
- named constructor: Allows multiple constructors
Dart multiple constructor examples
named constructors can be declared by adding more constructors to a class.
You can create multiple constructors with the constructor name. Each named constructor has a unique name
class Classname{
fields
// default one construcotr
Classname(fields)
Classname.unnamedconstructor(Classname other) :
// fields initialization
}
Here is a Multiple constructor example in dart
class Employee {
int _id = 0;
String _name = "";
// Default or unnamed constructor
Employee() {}
// named overloaded constructor
Employee.copy(Employee emp) {
this._id = emp._id;
this._name = emp._name;
}
// named overloaded constructor
Employee.changeData(int id, String name) {
this._id = id;
this._name = name;
}
String toString() {
String output = "Id:: " + _id.toString() + " , " + "Name - " + _name;
return output;
}
}
void main() {
// calls the default constructor
Employee emp = new Employee();
print(emp.toString());
// calls named constructor
Employee emp1 = new Employee.copy(emp);
print(emp1.toString());
// calls named constructor
Employee emp2 = new Employee.changeData(1, "John");
print(emp2.toString());
}
Output:
Name - , Id:: 0
Name - , Id:: 0
Name - John , Id:: 1
Another way, you can use factory constructors and static methods to achieve multiple constructor functionality
Factory named constructor
You can also define factory and static constructors with an overloaded version using the named constructor
// named factory constructor
factory Employee.factoryconstructor() {
return Employee.changeData(1, "franc");
}
// named static constructor
static Employee staticConstructor() {
return Employee.changeData(1, "franc");
}
You can call the factory and static constructor using the below code
// calls factory named constructor
Employee emp3 =Employee.factoryconstructor();
print(emp3.toString());
// calls static named constructor
Employee emp4 = Employee.staticConstructor();
print(emp4.toString());
Here is an
class Employee {
int _id = 0;
String _name = "";
// Default or unnamed constructor
Employee() {}
// named overloaded constructor
Employee.copy(Employee emp) {
this._id = emp._id;
this._name = emp._name;
}
// named overloaded constructor
Employee.changeData(int id, String name) {
this._id = id;
this._name = name;
}
String toString() {
String output = "Id:: " + _id.toString() + " , " + "Name - " + _name;
return output;
}
// named factory constructor
factory Employee.factoryconstructor() {
return Employee.changeData(1, "franc");
}
// named static constructor
static Employee staticConstructor() {
return Employee.changeData(1, "franc");
}
}
void main() {
// calls the default constructor
Employee emp = new Employee();
print(emp.toString());
// calls named constructor
Employee emp1 = new Employee.copy(emp);
print(emp1.toString());
// calls named constructor
Employee emp2 = new Employee.changeData(1, "John");
print(emp2.toString());
// calls factory named constructor
Employee emp3 =Employee.factoryconstructor();
print(emp3.toString());
// calls static named constructor
Employee emp4 = Employee.staticConstructor();
print(emp4.toString());
}
Multiple Named constructor inheritance example
Default behavior
If you have super and subclass in inheritance hierarchy classes. Constructor in subclass calls superclass constructor in case of default and named constructor
Here is an example that calls the constructor in the parent and child default constructor
- initializes data if required
- calls superclass constructor first
- Next, calls the subclass constructor
class Employee {
int _id = 0;
String _name = "";
// Default or unnamed constructor
Employee() {
print("Employee constructor");
}
}
class AdminEmployee extends Employee {
// Default or unnamed constructor
AdminEmployee() {
print("AdminEmployee constructor");
}
}
void main() {
// calls default Employee constructor
Employee emp = new Employee();
// calls default parent and child constructor
AdminEmployee emp1 = new AdminEmployee();
}
Next, In the case of the named constructor, Create a superclass named constructor followed by a colon(:
)and call the subclass named constructor
It calls following order when superclass is called
- Calls subclass named constructor
- calls superclass named constructor Here is an example
class Employee {
int _id = 0;
String _name = "";
// Default or unnamed constructor
Employee() {
print("Employee constructor");
}
// named constructor subclass
Employee.copy() {
print('Child Named constructor ');
}
}
class AdminEmployee extends Employee {
// Default or unnamed constructor
AdminEmployee() {
print("AdminEmployee constructor");
}
// named constructor superclass
AdminEmployee.copy() : super.copy() {
print('Parent Named constructor');
}
}
void main() {
// calls default Employee constructor
Employee emp = new Employee();
// calls default parent and child constructor
AdminEmployee emp1 = new AdminEmployee();
AdminEmployee emp2 = AdminEmployee.copy();
}
Output:
Employee constructor
Employee constructor
AdminEmployee constructor
Child Named constructor
Parent Named constructor