Transcript ini membahas 3 jenis constructor yang penting di Dart:

1. Default / unnamed constructor tanpa parameter
2. Parameterized / unnamed constructor dengan parameter
3. Named constructor

Ada satu konsep yang sangat penting di balik semuanya: Dart tidak mendukung constructor overloading seperti Java/C++, sehingga named constructor digunakan ketika kita membutuhkan beberapa cara berbeda untuk membuat object.

Saya jelaskan dari dasar sampai hubungan antar konsepnya.

1. Gambaran besar dulu

Bayangkan kita punya cetakan bernama Employee.

class Employee {
  String name;
  int salary;
  String role;
}

Kita ingin membuat object:

Employee e = Employee(...);

Constructor adalah mekanisme yang digunakan saat object tersebut dibuat.

Misalnya:

Employee("Budi", 5000000, "Manager")

Artinya kita membuat object Employee sekaligus memberikan data awalnya.

Nah, masalahnya:

Bagaimana kalau kita ingin membuat Employee dengan beberapa cara berbeda?

Misalnya:

Employee()
Employee("Budi", 5000000, "Manager")
Employee.admin("Andi", 7000000)
Employee.fromJson(...)

Dart menyediakan beberapa bentuk constructor untuk kebutuhan tersebut.

2. Default Constructor

Apa itu default constructor?

Dalam konteks transcript ini, default constructor adalah constructor yang tidak menerima parameter.

Contohnya:

class Employee {
  String? name;
  int? salary;
  String? role;

  Employee() {
    name = "Sam";
    salary = 25000;
    role = "Manager";
  }
}

Perhatikan:

Employee()

Tidak ada parameter di dalam ().

Jadi kita bisa menyebutnya:

zero-parameter constructor atau constructor tanpa parameter.

3. Ada dua kondisi “default constructor”

Ini bagian yang cukup penting.

Kondisi pertama: constructor tidak ditulis

Misalnya:

class Employee {
  String? name;
  int? salary;
  String? role;
}

Kita tidak menulis constructor sama sekali.

Dart menyediakan implicit unnamed constructor yang bisa dipanggil seperti:

Employee e = Employee();

Jadi:

Employee()

tetap bisa digunakan.

Namun constructor bawaan ini tidak otomatis mengisi:

name
salary
role

dengan data tertentu.

Kondisi kedua: kita menulis constructor sendiri

Misalnya:

class Employee {
  String? name;
  int? salary;
  String? role;

  Employee() {
    name = "Sam";
    salary = 25000;
    role = "Manager";
  }
}

Di sini constructor dibuat secara eksplisit oleh programmer.

Jadi ada perbedaan:

class Employee {
}

Dart menyediakan constructor tanpa parameter secara implisit.

Sedangkan:

class Employee {
  Employee() {
    // ...
  }
}

Kita sendiri yang menuliskannya.

4. Cara menggunakan default constructor

Kita bisa membuat object:

void main() {
  Employee e = Employee();

  print(e.name);
  print(e.salary);
  print(e.role);
}

Hasil:

Sam
25000
Manager

Alurnya:

Employee()
    ↓
constructor dipanggil
    ↓
name = "Sam"
salary = 25000
role = "Manager"
    ↓
object selesai dibuat

5. Kekurangan default constructor

Sekarang kita punya masalah.

Misalnya kita ingin membuat dua employee:

Employee e1 = Employee();
Employee e2 = Employee();

Keduanya akan mendapatkan:

Sam
25000
Manager

Kenapa?

Karena constructor selalu melakukan:

name = "Sam";
salary = 25000;
role = "Manager";

Jadi kita tidak bisa mengatakan:

Employee("Budi", 5000000, "Developer");

karena constructor kita tidak menerima parameter.

6. Analogi sederhana

Bayangkan constructor seperti formulir pendaftaran.

Default constructor:

Employee()

seperti formulir yang sudah diisi otomatis:

Nama  : Sam
Gaji  : 25000
Role  : Manager

Kita tidak diberi kesempatan memasukkan data sendiri.

Padahal kita mungkin ingin:

Nama  : Budi
Gaji  : 5000000
Role  : Developer

Untuk itu kita membutuhkan parameterized constructor.

7. Parameterized Constructor

Parameterized constructor adalah constructor yang menerima parameter.

Contohnya:

class Employee {
  String name;
  int salary;
  String role;

  Employee(String n, int s, String r) {
    name = n;
    salary = s;
    role = r;
  }
}

Sekarang constructor menerima tiga parameter:

String n
int s
String r

Kita bisa membuat object:

Employee e = Employee("Siddharth", 24000, "Team Leader");

Sekarang datanya bisa berbeda-beda.

8. Cara kerja parameterized constructor

Misalnya:

Employee e = Employee("Siddharth", 24000, "Team Leader");

Dart akan memasangkan argument berdasarkan posisi:

"Siddharth"  → n
24000        → s
"Team Leader"→ r

Kemudian constructor melakukan:

name = n;
salary = s;
role = r;

Sehingga object menjadi:

Employee Object

name   = Siddharth
salary = 24000
role   = Team Leader

9. Positional parameter

Contoh:

Employee(String n, int s, String r)

Ketiga parameter tersebut adalah positional parameter.

Artinya urutannya penting.

Employee("Budi", 5000000, "Developer");

berarti:

"Budi"       → n
5000000      → s
"Developer"  → r

Kalau kita menulis:

Employee(5000000, "Budi", "Developer");

akan error karena posisi dan tipe tidak sesuai.

10. Bisa menggunakan this

Dalam Dart, constructor seperti tadi biasanya ditulis lebih ringkas:

class Employee {
  String name;
  int salary;
  String role;

  Employee(this.name, this.salary, this.role);
}

Ini disebut initializing formal parameter.

Kode:

Employee(this.name, this.salary, this.role);

kurang lebih bermakna:

Employee(String name, int salary, String role) {
  this.name = name;
  this.salary = salary;
  this.role = role;
}

Jadi:

this.name

berarti field name milik object saat ini.

11. Masalah penting: default dan parameterized constructor

Sekarang perhatikan:

class Employee {
  Employee() {}

  Employee(String name, int salary, String role) {}
}

Bagi orang yang terbiasa dengan Java atau C++, ini mungkin terlihat normal.

Seolah-olah kita mempunyai:

Employee()
Employee(String, int, String)

Tetapi Dart tidak mendukung constructor overloading seperti itu.

Compiler akan menganggap kedua constructor tersebut memiliki nama constructor yang sama:

Employee

Jadi kita tidak bisa mendefinisikan dua unnamed constructor seperti itu dalam satu class.

12. Apa itu constructor overloading?

Constructor overloading adalah kemampuan untuk mempunyai beberapa constructor dengan nama yang sama tetapi parameter berbeda.

Contoh gaya Java/C++:

Employee()
Employee(String name)
Employee(String name, int salary)
Employee(String name, int salary, String role)

Semua namanya:

Employee

tetapi parameter berbeda.

Di Dart, pola seperti ini tidak diperbolehkan.

Jadi kita tidak bisa membuat:

Employee() {}

Employee(String name) {}

dalam class yang sama.

13. Lalu bagaimana kalau kita membutuhkan beberapa constructor?

Jawabannya:

Named Constructor

Inilah alasan named constructor sangat berguna.

Daripada:

Employee()
Employee(String name)
Employee(String name, int salary)

kita bisa membuat:

Employee()
Employee.admin(String name, int salary)
Employee.fromJson(...)

Nama constructornya sekarang berbeda.

14. Named Constructor

Contohnya:

class Employee {
  String name;
  int salary;
  String role;

  Employee(this.name, this.salary, this.role);

  Employee.admin(String n, int s) {
    name = n;
    salary = s;
    role = "Admin";
  }
}

Perhatikan:

Employee.admin(...)

Ini adalah named constructor.

Bagian:

Employee

adalah nama class.

Sedangkan:

admin

adalah nama constructor-nya.

15. Cara memanggil named constructor

Kalau unnamed constructor:

Employee("Siddharth", 24000, "Team Leader");

Maka named constructor:

Employee.admin("Mark", 50000);

Perhatikan titik:

Employee.admin(...)
        ↑

Titik tersebut memisahkan:

Nama class
    ↓
Employee
    ↓
Nama named constructor
    ↓
admin

Jadi:

Employee.admin()

dibaca kira-kira:

Buat object Employee menggunakan constructor bernama admin.

16. Contoh lengkap

Mari kita buat contoh yang lebih jelas:

class Employee {
  String name;
  int salary;
  String role;

  Employee(this.name, this.salary, this.role);

  Employee.admin(String name, int salary) {
    this.name = name;
    this.salary = salary;
    this.role = "Admin";
  }

  void showData() {
    print("Name   : $name");
    print("Salary : $salary");
    print("Role   : $role");
  }
}

Kemudian:

void main() {
  Employee e1 = Employee(
    "Siddharth",
    24000,
    "Team Leader",
  );

  Employee e2 = Employee.admin(
    "Mark",
    50000,
  );

  e1.showData();
  print("---");
  e2.showData();
}

Output:

Name   : Siddharth
Salary : 24000
Role   : Team Leader
---
Name   : Mark
Salary : 50000
Role   : Admin

17. Kenapa e1 dan e2 berbeda?

Karena kita menggunakan constructor yang berbeda.

e1

Employee(
  "Siddharth",
  24000,
  "Team Leader",
);

Menggunakan:

Employee(...)

yaitu unnamed constructor.

Data yang diberikan:

name = Siddharth
salary = 24000
role = Team Leader

e2

Employee.admin(
  "Mark",
  50000,
);

Menggunakan:

Employee.admin(...)

yaitu named constructor.

Constructor tersebut sendiri menentukan:

role = "Admin";

Jadi kita hanya perlu memberikan:

name
salary

Role otomatis menjadi:

Admin

18. Inilah kekuatan named constructor

Bayangkan sebuah class Employee mempunyai berbagai jenis employee:

Employee biasa
Admin
Manager
Guest
Developer

Kita bisa membuat:

class Employee {
  Employee(...);

  Employee.admin(...);

  Employee.manager(...);

  Employee.guest(...);

  Employee.developer(...);
}

Kemudian kita bisa membuat:

Employee e1 = Employee(
  "Budi",
  5000000,
  "Employee",
);

Employee e2 = Employee.admin(
  "Andi",
  7000000,
);

Employee e3 = Employee.manager(
  "Citra",
  10000000,
);

Ini membuat kode jauh lebih mudah dibaca.

19. Named constructor tidak harus bernama admin

Namanya bebas selama merupakan identifier Dart yang valid.

Misalnya:

class Employee {
  Employee(this.name, this.salary, this.role);

  Employee.fromGuest(String name) {
    this.name = name;
    salary = 0;
    role = "Guest";
  }

  String name;
  int salary;
  String role;
}

Bisa dipanggil:

Employee.fromGuest("Budi");

Nama yang sering ditemui dalam kode Dart/Flutter misalnya:

Person.fromJson(...)
DateTime.parse(...)
Color.fromARGB(...)

Konsepnya sama: constructor atau factory constructor yang diberi nama khusus untuk menunjukkan cara pembentukan object.

20. Named constructor bisa mempunyai parameter

Misalnya:

Employee.admin(String name, int salary)

Ada dua parameter.

Kita bisa juga menggunakan named parameter:

Employee.admin({
  required String name,
  required int salary,
}) {
  this.name = name;
  this.salary = salary;
  role = "Admin";
}

Pemanggilannya:

Employee.admin(
  name: "Mark",
  salary: 50000,
);

Jadi jangan mengira:

named constructor = named parameter.

Keduanya berbeda.

21. Named constructor vs named parameter

Ini sering membingungkan pemula.

Named constructor

Employee.admin(...)

admin adalah nama constructor.

Named parameter

Employee(
  name: "Mark",
  salary: 50000,
)

name dan salary adalah nama parameter.

Jadi:

Employee.admin(...)
        ↑
        named constructor


Employee(
  name: ...,
  salary: ...
)
  ↑
  named parameters

Keduanya bisa bahkan digunakan bersamaan:

Employee.admin(
  name: "Mark",
  salary: 50000,
);

22. Perbedaan ketiga jenis yang dibahas

Sekarang kita buat tabel sederhana.

Perhatikan hal penting:

Parameterized constructor bukan nama constructor khusus.

Parameterized constructor biasanya adalah unnamed constructor yang memiliki parameter.

Jadi:

Employee()

dan

Employee(String name)

sama-sama unnamed constructor.

Bedanya hanya:

Employee()
       ↓
tanpa parameter

Employee(String name)
       ↓
dengan parameter

23. Istilah “default constructor” perlu sedikit diluruskan

Transcript menyebut:

default constructor = constructor tanpa parameter.

Untuk pembelajaran dasar, ini cukup membantu.

Tetapi secara terminologi Dart, kita perlu hati-hati.

Ada perbedaan antara:

Constructor yang disediakan secara implicit

class Employee {
}

Dart dapat menyediakan unnamed constructor tanpa parameter.

dan:

Constructor tanpa parameter yang kita tulis sendiri

class Employee {
  Employee() {
    // ...
  }
}

Yang kedua adalah explicit unnamed constructor.

Jadi jangan terlalu terpaku bahwa:

default = selalu Employee()

Yang lebih penting untuk kamu pahami:

Unnamed constructor adalah constructor yang namanya sama dengan class tanpa nama tambahan seperti .admin.

24. Hubungan semuanya

Gambarkan seperti ini:

                     CONSTRUCTOR
                          │
             ┌────────────┴────────────┐
             │                         │
        UNNAMED CONSTRUCTOR       NAMED CONSTRUCTOR
             │                         │
       ┌─────┴─────┐             Employee.admin()
       │           │
   tanpa param   dengan param
       │           │
 Employee()    Employee(...)

Contohnya:

class Employee {
  // unnamed, tanpa parameter
  Employee();

  // named constructor
  Employee.admin();
}

Tetapi dua unnamed constructor tidak boleh:

class Employee {
  Employee();              // ❌
  Employee(String name);   // ❌
}

Karena keduanya bernama:

Employee

25. Kenapa named constructor penting di Flutter?

Konsep ini sangat sering kamu temui ketika belajar Flutter.

Flutter memiliki banyak class yang menyediakan constructor atau factory dengan nama tertentu untuk kebutuhan berbeda.

Misalnya konsep seperti:

Color.fromARGB(...)

atau:

EdgeInsets.all(...)
EdgeInsets.symmetric(...)
EdgeInsets.only(...)

Misalnya:

EdgeInsets.all(16)

berarti membuat EdgeInsets menggunakan cara all.

Sedangkan:

EdgeInsets.only(
  left: 10,
  right: 20,
)

menggunakan constructor bernama only.

Jadi ketika kamu nanti melihat:

Something.fromJson(...)
Something.fromMap(...)
Something.from...

jangan bingung.

Kemungkinan besar itu adalah named constructor atau factory constructor.

26. Contoh yang sangat mudah dibayangkan

Anggap Employee seperti mesin pembuat employee.

Cara 1 — employee biasa

Employee("Budi", 5000000, "Developer");

Kita memberikan semua informasi.

Cara 2 — admin

Employee.admin("Andi", 7000000);

Kita mengatakan:

“Buatkan employee yang tipe-nya Admin.”

Constructor sudah tahu:

role = "Admin";

Cara 3 — guest

Kita bisa membuat:

Employee.guest("Citra");

dan constructor menentukan:

salary = 0;
role = "Guest";

Dengan demikian pemanggilan constructor menjadi sangat deskriptif.

27. Contoh lengkap dengan tiga cara

Misalnya:

class Employee {
  String name;
  int salary;
  String role;

  // 1. Unnamed constructor tanpa parameter
  Employee() {
    name = "Unknown";
    salary = 0;
    role = "Employee";
  }

  // ❌ Tidak boleh membuat Employee(String ...)
  // karena itu akan menjadi unnamed constructor kedua.

  // 2. Named constructor
  Employee.admin(String name, int salary) {
    this.name = name;
    this.salary = salary;
    role = "Admin";
  }

  // 3. Named constructor lainnya
  Employee.guest(String name) {
    this.name = name;
    salary = 0;
    role = "Guest";
  }

  void showData() {
    print("Name: $name");
    print("Salary: $salary");
    print("Role: $role");
  }
}

Pemakaian:

void main() {
  Employee e1 = Employee();
  Employee e2 = Employee.admin("Budi", 5000000);
  Employee e3 = Employee.guest("Andi");

  e1.showData();
  print("---");

  e2.showData();
  print("---");

  e3.showData();
}

Hasil kira-kira:

Name: Unknown
Salary: 0
Role: Employee
---
Name: Budi
Salary: 5000000
Role: Admin
---
Name: Andi
Salary: 0
Role: Guest

28. Satu hal penting tentang non-nullable fields

Kalau menggunakan Dart modern dengan null safety, kode:

class Employee {
  String name;
  int salary;
  String role;
}

tidak bisa sembarangan membiarkan field-field tersebut belum diinisialisasi.

Salah satu solusi adalah constructor:

class Employee {
  String name;
  int salary;
  String role;

  Employee(this.name, this.salary, this.role);
}

Sekarang ketika membuat object:

Employee e = Employee(
  "Budi",
  5000000,
  "Developer",
);

semua field langsung memiliki nilai.

Ini salah satu alasan constructor sangat penting dalam Dart.

29. Jangan sampai tertukar dengan factory

Transcript sengaja belum membahas factory.

Untuk sekarang cukup ingat:

Unnamed constructor
Named constructor
Factory constructor

adalah konsep yang berbeda.

Factory constructor punya kemampuan khusus, misalnya constructor dapat memilih object mana yang akan dikembalikan dan tidak selalu membuat instance baru.

Jadi memang bagus dipelajari sebagai topik tersendiri setelah kamu sudah nyaman dengan constructor biasa.

30. Ringkasan paling penting

Kalau kamu hanya mengingat beberapa hal dari video ini, ingat ini:

1. Unnamed constructor

Nama constructor sama dengan class:

Employee()

Tidak ada nama tambahan setelah class.

2. Unnamed tanpa parameter

Employee() {
  // initialization
}

Tidak menerima argument.

3. Unnamed dengan parameter

Employee(String name, int salary, String role) {
  // initialization
}

Menerima data ketika object dibuat.

Ini biasa disebut parameterized constructor.

4. Dart tidak mendukung constructor overloading

Tidak boleh:

Employee();
Employee(String name);

dalam class yang sama.

Karena keduanya sama-sama bernama:

Employee

5. Gunakan named constructor untuk alternatif cara membuat object

Employee.admin(...)
Employee.guest(...)
Employee.fromJson(...)

Nama setelah titik adalah nama constructor:

Employee.admin
        ↑
        named constructor

6. Named constructor bisa banyak

Misalnya:

class Employee {
  Employee(...);

  Employee.admin(...);

  Employee.guest(...);

  Employee.manager(...);

  Employee.fromJson(...);
}

Ini memungkinkan satu class mempunyai banyak cara yang jelas untuk membuat object, tanpa constructor overloading.

31. Cheat sheet

class Employee {
  String name;
  int salary;
  String role;

  // Unnamed constructor
  Employee(this.name, this.salary, this.role);

  // Named constructor
  Employee.admin(String name, int salary)
      : this(name, salary, "Admin");

  // Named constructor lain
  Employee.guest(String name)
      : this(name, 0, "Guest");
}

Penggunaan:

Employee e1 = Employee(
  "Budi",
  5000000,
  "Developer",
);

Employee e2 = Employee.admin(
  "Andi",
  7000000,
);

Employee e3 = Employee.guest(
  "Citra",
);

Secara mental, baca seperti ini:

Employee(...)
       ↓
"Buat Employee dengan data yang saya berikan"

Employee.admin(...)
       ↓
"Buat Employee khusus melalui jalur admin"

Employee.guest(...)
       ↓
"Buat Employee khusus melalui jalur guest"

Inti video ini sebenarnya bukan sekadar menghafal 3 jenis constructor. Yang paling penting adalah memahami bahwa Dart tidak menggunakan constructor overloading, sehingga ketika kita membutuhkan beberapa cara untuk membuat object, kita bisa menggunakan named constructor untuk memberi masing-masing cara sebuah nama yang jelas.