Masukkan Password
53 6.2 What is Constructor in OOP | Object Oriented Programming Constructor in Dart | Dart Course
Materi kali ini membahas Constructor, dan ini adalah salah satu konsep OOP yang sangat penting karena constructor membuat proses pembuatan object menjadi jauh lebih mudah.
Ada sedikit koreksi dari caption:
- “DOT programming language” → maksudnya Dart
- “wi/white” → maksudnya
void - “this do” → maksudnya
this. - “nullable” → maksudnya nullable
- “H” pada beberapa bagian → maksudnya kemungkinan
age
1. Apa itu Constructor?
Secara sederhana:
Constructor adalah mekanisme khusus yang dijalankan secara otomatis ketika sebuah object dibuat.
Misalnya kita punya:
class Person {
Person() {
print("Object Person dibuat");
}
}
Kemudian:
void main() {
Person person = Person();
}
Ketika baris ini dijalankan:
Person person = Person();
constructor:
Person() {
print("Object Person dibuat");
}
langsung dijalankan secara otomatis.
Output:
Object Person dibuat
Kita tidak perlu menulis:
person.Person();
atau memanggil constructor secara manual.
2. Kenapa Constructor dibutuhkan?
Kita kembali ke materi sebelumnya.
Misalnya kita punya class:
class Person {
late String name;
late int age;
}
Untuk mengisi datanya, kita harus melakukan:
void main() {
Person person = Person();
person.name = "Budi";
person.age = 20;
}
Artinya kita melakukan dua tahap:
1. Buat object
↓
2. Isi data object
Constructor memungkinkan kita melakukan inisialisasi ketika object dibuat.
Misalnya:
class Person {
late String name;
late int age;
Person(String name, int age) {
this.name = name;
this.age = age;
}
}
Sekarang:
void main() {
Person person = Person("Budi", 20);
}
Begitu object dibuat:
Person person = Person("Budi", 20);
constructor langsung menerima:
name = "Budi"
age = 20
dan mengisi property object.
Jadi constructor sangat berguna untuk:
memberikan nilai awal kepada object.
3. Constructor berbeda dengan method biasa
Perhatikan:
class Person {
Person() {
print("Constructor");
}
void display() {
print("Display");
}
}
Di sini ada dua hal berbeda:
Person()
↓
Constructor
display()
↓
Method biasa
Kalau kita membuat object:
Person person = Person();
Person() langsung berjalan.
Tetapi display() tidak otomatis berjalan.
Kita harus memanggilnya:
person.display();
Jadi:
Constructor → otomatis dijalankan saat object dibuat
Method → harus dipanggil secara eksplisit
4. Ciri-ciri Constructor
Constructor Dart memiliki beberapa ciri penting.
1. Namanya sama dengan class
Kalau class:
class Person {
}
constructor-nya:
Person() {
}
Kalau:
class Student {
}
constructor:
Student() {
}
Kalau:
class BankAccount {
}
constructor:
BankAccount() {
}
2. Tidak mempunyai return type
Constructor tidak boleh memiliki:
void
String
int
double
bool
di depannya.
❌ Salah:
void Person() {
}
❌ Salah:
String Person() {
}
❌ Salah:
int Person() {
}
✅ Benar:
Person() {
}
Ini perbedaan penting dengan function biasa.
3. Dipanggil otomatis ketika object dibuat
Misalnya:
class Person {
Person() {
print("Constructor dijalankan");
}
}
Kemudian:
Person person = Person();
Constructor otomatis berjalan.
5. Constructor tanpa parameter
Constructor paling sederhana adalah constructor tanpa parameter.
class Person {
Person() {
print("Hello from constructor");
}
}
Kemudian:
void main() {
Person person = Person();
}
Output:
Hello from constructor
Constructor seperti ini tidak menerima data.
6. Disebut Default Constructor?
Dalam konteks materi pemula, constructor tanpa parameter sering disebut default constructor.
Contohnya:
Person() {
print("Constructor");
}
Tetapi ada sedikit hal yang perlu kamu pahami:
Dart juga dapat menyediakan default unnamed constructor secara otomatis kalau kita tidak mendeklarasikan constructor sendiri.
Misalnya:
class Person {
late String name;
}
Kita tetap bisa:
Person person = Person();
Karena Dart menyediakan constructor default yang sesuai.
Namun kalau kita sudah membuat constructor sendiri:
class Person {
Person(String name) {
// ...
}
}
maka kita tidak lagi memiliki constructor tanpa parameter secara otomatis.
7. Constructor dengan Parameter
Sekarang kita buat constructor yang menerima data.
class Person {
late String name;
late int age;
Person(String name, int age) {
this.name = name;
this.age = age;
}
}
Kemudian:
void main() {
Person person = Person("Budi", 20);
}
Mari kita lihat apa yang terjadi.
Ketika:
Person person = Person("Budi", 20);
dijalankan:
"Budi"
↓
parameter name
20
↓
parameter age
Kemudian constructor menjalankan:
this.name = name;
this.age = age;
Hasil akhirnya:
object person
│
├── name = "Budi"
└── age = 20
8. Kenapa menggunakan this?
Ini berkaitan dengan pembahasan sebelumnya.
Kita memiliki property:
late String name;
late int age;
Dan constructor memiliki parameter:
Person(String name, int age)
Perhatikan bahwa namanya sama:
class property parameter
↓ ↓
name name
age age
Maka kita menggunakan:
this.name = name;
this.age = age;
Artinya:
this.name
↓
name milik object
name
↓
parameter constructor
Jadi:
this.name = name;
dibaca:
Masukkan nilai
namedari parameter ke propertynamemilik object ini.
9. Analogi this
Bayangkan kamu mempunyai sebuah kotak.
Kotak tersebut memiliki:
name
age
Kemudian seseorang memberikan:
name = Budi
age = 20
Kita mengatakan:
this.name = name
this.age = age
Artinya:
property object ← nilai parameter
atau:
this.name ← name
this.age ← age
10. Constructor dengan positional parameter
Constructor sebelumnya:
Person(String name, int age) {
this.name = name;
this.age = age;
}
menggunakan positional parameter.
Ketika memanggil:
Person("Budi", 20);
urutan penting.
"Budi" → name
20 → age
Kalau:
Person(20, "Budi");
akan salah karena tipe dan posisinya tidak sesuai.
11. Named Parameter pada Constructor
Dart juga mendukung named parameter.
Contoh:
class Person {
late String name;
late int age;
Person({
required String name,
required int age,
}) {
this.name = name;
this.age = age;
}
}
Sekarang pemanggilannya:
Person person = Person(
name: "Budi",
age: 20,
);
Perhatikan perbedaannya.
Positional
Person("Budi", 20);
Urutan harus benar.
Named
Person(
name: "Budi",
age: 20,
);
Kita menyebut nama parameternya.
12. required pada Constructor
Perhatikan:
required String name
required berarti:
Parameter tersebut wajib diberikan ketika constructor dipanggil.
Misalnya:
Person person = Person(
name: "Budi",
age: 20,
);
Benar.
Tetapi:
Person person = Person(
name: "Budi",
);
akan error karena age wajib diberikan.
13. Constructor dengan default value
Kita juga bisa memberikan nilai default.
Misalnya:
class Person {
late String name;
late int age;
Person({
required String name,
int age = 18,
}) {
this.name = name;
this.age = age;
}
}
Sekarang kita bisa:
Person person = Person(
name: "Budi",
);
Karena age memiliki default:
age = 18
Maka object menjadi:
name = Budi
age = 18
Kalau kita ingin mengubahnya:
Person person = Person(
name: "Budi",
age: 20,
);
Maka:
name = Budi
age = 20
14. Bentuk pendek Constructor
Nah, Dart mempunyai fitur yang sangat praktis.
Daripada menulis:
class Person {
late String name;
late int age;
Person(String name, int age) {
this.name = name;
this.age = age;
}
}
kita bisa menulis:
class Person {
String name;
int age;
Person(this.name, this.age);
}
Ini disebut constructor shorthand / initializing formal parameter.
Jauh lebih pendek.
15. Bagaimana cara membaca Person(this.name, this.age)?
Ini memang terlihat aneh pertama kali.
Person(this.name, this.age);
Anggap saja ini bentuk singkat dari:
Person(String name, int age) {
this.name = name;
this.age = age;
}
Jadi:
Person(this.name, this.age);
secara konsep berarti:
parameter name
↓
this.name
parameter age
↓
this.age
16. Constructor shorthand dengan named parameter
Kita juga bisa menggabungkannya dengan named parameter.
class Person {
String name;
int age;
Person({
required this.name,
required this.age,
});
}
Kemudian:
Person person = Person(
name: "Budi",
age: 20,
);
Ini adalah bentuk yang sangat sering kamu temui dalam kode Dart/Flutter.
17. Named parameter + default value
Kita juga bisa:
class Person {
String name;
int age;
Person({
required this.name,
this.age = 18,
});
}
Kemudian:
Person person = Person(
name: "Budi",
);
Maka:
name = Budi
age = 18
Atau:
Person person = Person(
name: "Budi",
age: 20,
);
Maka:
name = Budi
age = 20
18. Constructor sangat berguna untuk menghindari late
Perhatikan cara lama:
class Person {
late String name;
late int age;
}
Kita harus:
Person person = Person();
person.name = "Budi";
person.age = 20;
Dengan constructor:
class Person {
String name;
int age;
Person(this.name, this.age);
}
Kita langsung:
Person person = Person("Budi", 20);
Lebih aman dan lebih rapi.
Bahkan property:
String name;
int age;
tidak perlu late, karena nilainya langsung diberikan ketika object dibuat.
19. Contoh lengkap yang saya rekomendasikan
Untuk memahami konsep ini, coba perhatikan program berikut:
class Person {
String name;
int age;
Person({
required this.name,
required this.age,
});
void display() {
print("Name: $name");
print("Age: $age");
}
}
void main() {
Person person = Person(
name: "Budi",
age: 20,
);
person.display();
}
Output:
Name: Budi
Age: 20
Mari kita pecah.
Class
class Person {
Kita membuat class Person.
Properties
String name;
int age;
Object memiliki:
name
age
Constructor
Person({
required this.name,
required this.age,
});
Constructor meminta data ketika object dibuat.
Membuat object
Person person = Person(
name: "Budi",
age: 20,
);
Constructor menerima:
name = Budi
age = 20
Method
person.display();
Menampilkan data object.
20. Perbedaan cara lama vs Constructor
Tanpa constructor
class Person {
late String name;
late int age;
}
void main() {
Person person = Person();
person.name = "Budi";
person.age = 20;
}
Dengan constructor
class Person {
String name;
int age;
Person(this.name, this.age);
}
void main() {
Person person = Person("Budi", 20);
}
Constructor membuat object langsung siap digunakan.
21. Constructor tidak mengembalikan nilai
Ini perlu benar-benar diingat.
Function biasa:
String getName() {
return "Budi";
}
Function memiliki return type:
String
Method:
int calculate() {
return 10 + 20;
}
memiliki:
int
Tetapi constructor:
Person(String name) {
this.name = name;
}
tidak mempunyai:
void
String
int
Jadi jangan menulis:
void Person() {}
Karena Dart akan menganggapnya sebagai sesuatu yang tidak valid untuk constructor.
22. Constructor vs Function biasa
| Constructor | Function/Method |
|---|---|
| Namanya sama dengan class | Namanya bebas |
| Tidak memiliki return type | Bisa memiliki return type |
| Berhubungan dengan pembuatan/inisialisasi object | Melakukan suatu operasi |
| Berjalan saat object dibuat | Biasanya dipanggil secara manual |
Contoh Person(...) | Contoh display() |
Contoh:
class Person {
Person() {
// constructor
}
void display() {
// method
}
}
Saat:
Person person = Person();
yang otomatis dipanggil adalah:
Person()
Bukan:
display()
23. Satu Class bisa memiliki constructor yang lebih dari satu?
Bisa, tetapi ada aturan.
Dart mendukung beberapa named constructors.
Contohnya:
class Person {
String name;
int age;
Person(this.name, this.age);
Person.guest()
: name = "Guest",
age = 0;
}
Kemudian:
Person person1 = Person("Budi", 20);
Person person2 = Person.guest();
Jadi ada:
Person(...)
↓
constructor utama
Person.guest()
↓
named constructor
Ini akan menjadi materi yang biasanya dibahas setelah constructor dasar.
24. Alur Constructor secara keseluruhan
Saat kita menulis:
Person person = Person(
name: "Budi",
age: 20,
);
bayangkan prosesnya seperti ini:
Person(...)
│
↓
Constructor dijalankan
│
┌────────┴────────┐
↓ ↓
name = "Budi" age = 20
│ │
└────────┬────────┘
↓
Object Person
│
↓
person
Jadi constructor adalah semacam gerbang masuk saat object pertama kali dibuat.
25. Analogi paling gampang
Bayangkan class adalah formulir pendaftaran siswa.
Class:
Student
├── name
├── age
└── school
Constructor adalah petugas yang berkata:
“Saat siswa baru dibuat, berikan saya nama, umur, dan sekolahnya.”
Misalnya:
Student(
name: "Budi",
age: 20,
school: "SMAN 1",
);
Maka object langsung mempunyai:
name = Budi
age = 20
school = SMAN 1
Tanpa harus:
student.name = "Budi";
student.age = 20;
student.school = "SMAN 1";
26. Kesimpulan materi
Kalau kamu hanya ingin mengingat inti materi hari ini, pegang 8 poin ini:
1. Constructor digunakan untuk menginisialisasi object
Person("Budi", 20);
2. Constructor berjalan otomatis saat object dibuat
Person person = Person();
3. Nama constructor sama dengan nama class
class Person {
Person() {}
}
4. Constructor tidak mempunyai return type
❌
void Person() {}
✅
Person() {}
5. Constructor bisa menerima parameter
Person(String name, int age) {
this.name = name;
this.age = age;
}
6. Bisa menggunakan named parameter
Person({
required this.name,
required this.age,
});
7. Bisa menggunakan default value
Person({
required this.name,
this.age = 18,
});
8. Constructor punya bentuk singkat
Daripada:
Person(String name, int age) {
this.name = name;
this.age = age;
}
bisa:
Person(this.name, this.age);
🧠 Hubungkan dengan materi sebelumnya
Sekarang pengetahuan OOP kamu mulai tersusun:
CLASS
↓
cetakan/template
↓
CONSTRUCTOR
↓
menyiapkan data awal
↓
OBJECT
↓
memiliki
├── properties/fields
│ ├── name
│ └── age
│
└── methods
└── display()
Contoh paling sederhana yang sebaiknya kamu kuasai:
class Person {
String name;
int age;
Person({
required this.name,
required this.age,
});
void display() {
print("Name: $name");
print("Age: $age");
}
}
void main() {
Person person = Person(
name: "Budi",
age: 20,
);
person.display();
}
Kalau kamu sudah benar-benar memahami kode di atas, berarti kamu sudah memahami hubungan class → constructor → object → property → method, yang merupakan fondasi penting sebelum masuk ke konsep OOP berikutnya seperti encapsulation, getter/setter, inheritance, dan polymorphism.
Saya juga bisa membuat gambar/diagram visual alur Constructor → Object → Property supaya konsepnya lebih mudah diingat.