Masukkan Password
54 6.3 What is Named Constructor in OOP | Object Oriented Programming in Dart | Learn Dart: Dart Course
Materi kali ini membahas Named Constructor di Dart. Ini merupakan lanjutan langsung dari constructor biasa yang kita bahas sebelumnya.
Kalau constructor biasa sudah kamu pahami, materi ini sebenarnya cukup masuk akal:
Named Constructor memungkinkan kita memiliki beberapa constructor dalam satu class dengan nama yang berbeda.
Ada beberapa koreksi dari caption:
- “DOT” → Dart
- “student dot dot” →
student.dart - “role” / “rooll” → kemungkinan
roleNumber - “from map” →
Student.fromMap(...) - “map string dynamic” →
Map<String, dynamic>
1. Kenapa kita membutuhkan Named Constructor?
Kita sudah tahu constructor biasa.
Misalnya:
class Student {
Student() {
print("Default Constructor");
}
}
Kemudian:
Student student = Student();
Constructor tersebut dipanggil otomatis.
Sekarang bayangkan kita ingin membuat dua constructor:
class Student {
Student() {
print("Constructor 1");
}
Student() {
print("Constructor 2");
}
}
Ini tidak boleh di Dart.
Dart akan mengatakan bahwa constructor dengan nama yang sama sudah didefinisikan.
Jadi kita tidak bisa melakukan constructor overloading berdasarkan parameter seperti di beberapa bahasa lain.
2. Solusinya: Named Constructor
Dart menyediakan konsep named constructor.
Contoh:
class Student {
Student() {
print("Default Constructor");
}
Student.fromName() {
print("Named Constructor");
}
}
Perhatikan:
Student()
adalah constructor biasa/unnamed.
Sedangkan:
Student.fromName()
adalah named constructor.
Bagian:
Student.fromName()
└──────┘
nama constructor
3. Cara membuat Named Constructor
Format sederhananya:
class NamaClass {
NamaClass.namaConstructor() {
}
}
Contoh:
class Student {
Student() {
print("Default Constructor");
}
Student.fromName() {
print("Named Constructor");
}
}
Nama class:
Student
Nama named constructor:
fromName
Jadi nama lengkapnya:
Student.fromName
4. Cara memanggil Named Constructor
Ini bagian yang sangat penting.
Kalau constructor biasa:
Student();
Kalau named constructor:
Student.fromName();
Contoh:
class Student {
Student() {
print("Default Constructor");
}
Student.fromName() {
print("Named Constructor");
}
}
void main() {
Student student1 = Student();
Student student2 = Student.fromName();
}
Output:
Default Constructor
Named Constructor
5. Perbedaan Constructor biasa dan Named Constructor
Mari kita bandingkan.
Unnamed Constructor
Student();
Named Constructor
Student.fromName();
Secara sederhana:
Student()
↓
constructor biasa
Student.fromName()
↓
named constructor
6. Apakah Named Constructor otomatis dipanggil?
Tidak.
Ini perbedaan penting.
Ketika:
Student student = Student();
constructor Student() dijalankan.
Tetapi ketika class memiliki:
Student.fromName()
constructor tersebut tidak dijalankan hanya karena class digunakan.
Kita harus membuat object menggunakan constructor tersebut:
Student student = Student.fromName();
Jadi:
Student()
↓
dipanggil ketika object dibuat dengan Student()
Student.fromName()
↓
dipanggil ketika object dibuat dengan Student.fromName()
7. Bisa punya banyak Named Constructor
Nah, inilah alasan utama named constructor digunakan.
Kita bisa memiliki:
class Student {
Student() {
}
Student.fromName() {
}
Student.fromMap() {
}
Student.fromJson() {
}
Student.empty() {
}
}
Ini sah karena setiap constructor memiliki nama berbeda.
Jadi:
Student()
Student.fromName()
Student.fromMap()
Student.fromJson()
Student.empty()
berbeda satu sama lain.
8. Kenapa tidak bisa membuat constructor biasa banyak?
Karena semua unnamed constructor memiliki nama yang sama, yaitu nama class.
Misalnya:
Student()
dan:
Student(String name)
Keduanya tetap bernama:
Student
Jadi Dart tidak mengizinkan kita membuat beberapa unnamed constructor seperti itu.
Dengan named constructor:
Student()
Student.fromName()
Student.fromMap()
nama constructor menjadi berbeda.
9. Named Constructor dengan Parameter
Sekarang kita masuk ke contoh yang lebih berguna.
Misalnya:
class Student {
late String name;
late int roleNumber;
late int age;
Student.fromData(String name, int roleNumber, int age) {
this.name = name;
this.roleNumber = roleNumber;
this.age = age;
}
void display() {
print("Name: $name");
print("Role Number: $roleNumber");
print("Age: $age");
}
}
Kemudian:
void main() {
Student student = Student.fromData(
"Budi",
10,
20,
);
student.display();
}
Output:
Name: Budi
Role Number: 10
Age: 20
10. Apa yang terjadi di belakang layar?
Ketika kita menulis:
Student.fromData("Budi", 10, 20);
parameter constructor menerima:
name = "Budi"
roleNumber = 10
age = 20
Kemudian:
this.name = name;
this.roleNumber = roleNumber;
this.age = age;
mengisi property object.
Hasilnya:
student
├── name = "Budi"
├── roleNumber = 10
└── age = 20
11. Named Constructor sebenarnya tetap Constructor
Jangan menganggap named constructor sebagai sesuatu yang benar-benar berbeda dari constructor.
Dia tetap constructor.
Perbedaannya terutama adalah namanya.
Constructor biasa:
Student();
Named constructor:
Student.fromData();
Keduanya sama-sama digunakan untuk membuat dan menginisialisasi object.
12. Contoh yang lebih realistis
Misalnya kita mempunyai class Person.
class Person {
String name;
int age;
Person(this.name, this.age);
Person.guest()
: name = "Guest",
age = 0;
}
Sekarang ada dua cara membuat Person.
Cara pertama
Person person1 = Person("Budi", 20);
Hasil:
name = Budi
age = 20
Cara kedua
Person person2 = Person.guest();
Hasil:
name = Guest
age = 0
Jadi named constructor bisa memberikan cara alternatif untuk membuat object.
13. Analogi sederhana
Bayangkan class Person seperti sebuah pabrik.
Pabrik tersebut punya beberapa pintu masuk:
PERSON
│
┌─────────┼─────────┐
↓ ↓ ↓
Person() Person.guest()
Person.fromMap()
Semua menghasilkan object Person.
Tetapi cara mendapatkan data awalnya bisa berbeda.
Misalnya:
Person()
↓
object kosong/default
Person.guest()
↓
object Guest
Person.fromMap()
↓
object dari data Map
14. Bagian penting: fromMap
Ini bagian terakhir dari materi dan cukup penting, terutama nanti ketika belajar Flutter/API/database.
Misalnya kita punya data:
Map<String, dynamic> data = {
"name": "Budi",
"roleNumber": 10,
"age": 20,
};
Kita ingin mengubah data Map tersebut menjadi object Student.
Kita bisa membuat:
class Student {
String name;
int roleNumber;
int age;
Student.fromMap(Map<String, dynamic> map)
: name = map["name"],
roleNumber = map["roleNumber"],
age = map["age"];
}
Kemudian:
void main() {
Map<String, dynamic> data = {
"name": "Budi",
"roleNumber": 10,
"age": 20,
};
Student student = Student.fromMap(data);
print(student.name);
}
Output:
Budi
15. Kenapa fromMap berguna?
Karena dalam aplikasi nyata kita sering mendapatkan data dalam bentuk Map.
Misalnya dari API:
{
"name": "Budi",
"age": 20,
"city": "Madiun"
}
Dart bisa merepresentasikannya sebagai:
Map<String, dynamic>
Tetapi kita mungkin ingin mengubahnya menjadi object:
Person
Maka kita membuat:
Person.fromMap(data);
Alurnya:
Data dari API / JSON
↓
Map
↓
Person.fromMap()
↓
Object
↓
Person
Ini adalah pola yang sangat sering digunakan dalam pengembangan aplikasi.
16. Memahami Map<String, dynamic>
Kita sudah pernah membahas Map.
Contoh:
Map<String, dynamic> data = {
"name": "Budi",
"age": 20,
};
Artinya:
Map
│
├── "name" → "Budi"
└── "age" → 20
String berarti key-nya berupa String.
"name"
"age"
Sedangkan:
dynamic
berarti value bisa mempunyai berbagai tipe:
"Budi" → String
20 → int
true → bool
17. Cara kerja Student.fromMap()
Misalnya:
class Student {
String name;
int roleNumber;
int age;
Student.fromMap(Map<String, dynamic> map)
: name = map["name"],
roleNumber = map["roleNumber"],
age = map["age"];
}
Kita punya:
Map<String, dynamic> data = {
"name": "Budi",
"roleNumber": 10,
"age": 20,
};
Kemudian:
Student student = Student.fromMap(data);
Maka:
map["name"]
↓
Budi
↓
student.name
map["roleNumber"]
↓
10
↓
student.roleNumber
map["age"]
↓
20
↓
student.age
Sehingga object:
Student
├── name = "Budi"
├── roleNumber = 10
└── age = 20
18. Kenapa menggunakan : pada contoh fromMap?
Kamu mungkin melihat bentuk:
Student.fromMap(Map<String, dynamic> map)
: name = map["name"],
roleNumber = map["roleNumber"],
age = map["age"];
Bagian setelah:
:
disebut initializer list.
Untuk sekarang, cukup pahami secara sederhana:
Initializer list digunakan untuk memberikan nilai awal kepada field sebelum constructor body dijalankan.
Contoh:
Student.fromMap(Map<String, dynamic> map)
: name = map["name"],
roleNumber = map["roleNumber"],
age = map["age"];
artinya:
name ← map["name"]
roleNumber ← map["roleNumber"]
age ← map["age"]
Nanti konsep initializer list akan semakin jelas ketika kamu mempelajari constructor lebih lanjut.
19. Versi dengan constructor body
Untuk pemula, kamu juga bisa membayangkan konsep yang sama menggunakan body:
class Student {
late String name;
late int roleNumber;
late int age;
Student.fromMap(Map<String, dynamic> map) {
name = map["name"];
roleNumber = map["roleNumber"];
age = map["age"];
}
}
Secara konsep mudah dipahami:
Map
↓
ambil data
↓
masukkan ke property
↓
Object Student
Namun initializer list adalah bentuk yang lebih idiomatis ketika field non-nullable perlu diinisialisasi langsung.
20. Named Constructor bisa memiliki nama apa saja?
Secara teknis kita bisa membuat nama seperti:
Person.guest()
Person.fromMap()
Person.fromJson()
Person.empty()
Person.admin()
Person.student()
Nama tersebut dipilih sesuai tujuan.
Contoh:
class User {
User.fromMap(...) {}
User.fromJson(...) {}
User.guest() {}
}
Ini memberi petunjuk kepada programmer:
fromMap → object dibuat dari Map
fromJson → object dibuat dari JSON
guest → object dibuat sebagai Guest
Jadi named constructor juga membantu membuat kode lebih mudah dibaca.
21. Contoh beberapa Named Constructor
Misalnya:
class User {
String name;
int age;
User(this.name, this.age);
User.guest()
: name = "Guest",
age = 0;
User.fromMap(Map<String, dynamic> map)
: name = map["name"],
age = map["age"];
}
Sekarang kita memiliki tiga cara:
Cara 1
User user1 = User("Budi", 20);
Cara 2
User user2 = User.guest();
Cara 3
User user3 = User.fromMap({
"name": "Andi",
"age": 25,
});
Semua menghasilkan object User.
22. Named Constructor vs Function
Sekilas:
User.fromMap(data);
terlihat seperti function biasa.
Tetapi ada perbedaan penting.
User.fromMap() adalah constructor, karena:
- namanya berkaitan dengan class
User - digunakan untuk membuat object
User - dipanggil melalui nama class
Sedangkan:
user.display();
adalah method biasa.
Jadi:
User.fromMap()
↓
Constructor
user.display()
↓
Method
23. Constructor bisa langsung menjalankan method?
Secara teknis body constructor bisa menjalankan kode lain, termasuk method, tetapi ada pertimbangan desain.
Misalnya:
class Student {
late String name;
Student(String name) {
this.name = name;
show();
}
void show() {
print(name);
}
}
Ketika:
Student student = Student("Budi");
constructor akan mengisi name, kemudian show() dijalankan.
Output:
Budi
Namun dalam praktik, constructor biasanya lebih baik fokus pada inisialisasi object, bukan melakukan terlalu banyak pekerjaan atau efek samping seperti mencetak data.
Jadi untuk pembelajaran, pahami bahwa bisa, tetapi tidak berarti selalu sebaiknya dilakukan.
24. Hal yang sangat penting: Named Constructor bukan berarti constructor dipanggil otomatis semuanya
Misalnya:
class Student {
Student() {
print("Default");
}
Student.fromMap(Map<String, dynamic> map) {
print("From Map");
}
}
Kalau kita:
Student student = Student();
yang berjalan hanya:
Default
Kalau:
Student student = Student.fromMap({});
yang berjalan:
From Map
Jadi hanya constructor yang digunakan saat object dibuat yang dijalankan.
25. Kesalahan yang sering dilakukan pemula
❌ Salah 1 — Membuat dua unnamed constructor
class Student {
Student() {}
Student(String name) {}
}
Tidak diperbolehkan.
Gunakan named constructor:
class Student {
Student() {}
Student.fromName(String name) {}
}
❌ Salah 2 — Memanggil named constructor tanpa nama
Student();
Ini memanggil unnamed constructor.
Kalau ingin fromMap:
Student.fromMap(data);
❌ Salah 3 — Menganggap semua constructor otomatis dijalankan
Tidak.
Hanya constructor yang digunakan untuk membuat object.
❌ Salah 4 — Mengira named constructor adalah method biasa
Misalnya:
student.fromMap();
Bukan begitu.
Constructor dipanggil melalui class:
Student.fromMap(data);
26. Perbandingan semua jenis yang sudah kita pelajari
| Bentuk | Contoh | Fungsi |
|---|---|---|
| Unnamed constructor | Person() | Constructor utama/tanpa nama |
| Positional constructor | Person("Budi", 20) | Menerima parameter berdasarkan posisi |
| Named constructor | Person.guest() | Constructor dengan nama khusus |
| Named + parameter | Person.fromMap(data) | Membuat object dari sumber data tertentu |
| Default value | Person(name, age = 18)* | Memberikan nilai default |
- Bentuk pastinya bergantung apakah parameter positional atau named.
27. Pola yang akan sering kamu lihat nanti
Saat belajar Flutter/Dart lebih lanjut, kamu mungkin sering melihat:
User.fromJson(...)
atau:
Product.fromMap(...)
atau:
DateTime(...)
Pola fromMap / fromJson sangat umum untuk mengubah data eksternal menjadi object.
Contohnya:
Server/API
↓
JSON
↓
Map<String, dynamic>
↓
User.fromMap()
↓
User object
Kemudian object tersebut bisa digunakan dengan lebih nyaman:
print(user.name);
print(user.age);
daripada terus-menerus:
print(data["name"]);
print(data["age"]);
28. Gambaran besar materi ini
Coba simpan diagram berikut di kepala:
CLASS
Student
│
┌───────────┼────────────┐
↓ ↓ ↓
Student() Student.fromMap()
│ │
│ │
↓ ↓
object biasa object dari Map
Dan kalau constructor-nya banyak:
Student
│
┌──────────┼───────────┐
↓ ↓ ↓
Student() Student.guest() Student.fromMap()
│ │ │
↓ ↓ ↓
Object 1 Object 2 Object 3
29. Contoh final yang sebaiknya kamu pahami
Ini contoh yang menurut saya paling bagus untuk merangkum materi:
class Student {
String name;
int age;
// Unnamed constructor
Student(this.name, this.age);
// Named constructor
Student.guest()
: name = "Guest",
age = 0;
// Named constructor dari Map
Student.fromMap(Map<String, dynamic> map)
: name = map["name"],
age = map["age"];
void display() {
print("Name: $name");
print("Age: $age");
}
}
void main() {
Student student1 = Student("Budi", 20);
Student student2 = Student.guest();
Student student3 = Student.fromMap({
"name": "Andi",
"age": 25,
});
student1.display();
student2.display();
student3.display();
}
Output:
Name: Budi
Age: 20
Name: Guest
Age: 0
Name: Andi
Age: 25
Perhatikan bahwa ketiganya adalah object dari class yang sama:
Student
│
├── student1
│ └── dibuat dengan Student(...)
│
├── student2
│ └── dibuat dengan Student.guest()
│
└── student3
└── dibuat dengan Student.fromMap(...)
🧠 Kesimpulan paling penting
Kalau disederhanakan:
Constructor biasa
Student();
Adalah constructor tanpa nama tambahan.
Named Constructor
Student.fromMap();
Student.guest();
Student.fromJson();
Adalah constructor yang memiliki nama tambahan setelah ..
Tujuan utamanya adalah:
Memberikan beberapa cara berbeda untuk membuat dan menginisialisasi object dari class yang sama.
Jadi kalau kamu menemukan:
User.fromMap(data)
jangan bingung. Bacanya:
“Buat object
Usermenggunakan constructor bernamafromMap, dengan datadata.”
Dan kalau menemukan:
Product.fromJson(json)
bacanya:
“Buat object
Productdari data JSON menggunakan named constructorfromJson.”
Ini konsep yang nantinya sangat sering muncul ketika kamu mulai belajar JSON, API, database, dan Flutter.