Masukkan Password
52 6.1 What are Classes & Objects in OOP | Learn Object Oriented Programming in Dart | Dart Course
Materi ini melanjutkan pembahasan OOP (Object-Oriented Programming), dan fokus utamanya adalah memahami hubungan antara class dan object, cara membuat object, cara mengakses isi class, penggunaan this, serta cara memisahkan class ke file yang berbeda.
Ada beberapa kesalahan transkripsi dari caption yang perlu diluruskan:
- “DOT programming language” → maksudnya Dart programming language
- “dot file” → maksudnya file
.dart - “student dot dot” → maksudnya
student.dart - “object dot” → maksudnya
object.
1. Gambaran besar materi
Sebelum masuk kode, pahami dulu konsep paling penting:
Class adalah cetakan/template, sedangkan object adalah benda nyata yang dibuat dari cetakan tersebut.
Misalnya kita ingin membuat program tentang siswa.
Kita bisa membuat:
class Student {
String name;
int age;
String school;
}
Student di sini adalah class.
Kemudian kita membuat siswa sungguhan:
Student student1 = Student();
student1 adalah object dari class Student.
Gambaran sederhananya:
CLASS
Student
├── name
├── age
└── school
↓
↓ dibuat menjadi
↓
OBJECT
student1
├── name = "Budi"
├── age = 20
└── school = "SMAN 1"
Jadi:
Class = cetakan
Object = hasil dari cetakan
2. Apa itu Class?
Class adalah blueprint atau cetakan yang digunakan untuk membuat object.
Contoh di dunia nyata:
Bayangkan ada cetakan untuk membuat rumah.
Cetakan tersebut menentukan:
- jumlah kamar
- luas rumah
- jumlah lantai
- posisi pintu
Tetapi cetakan itu sendiri bukan rumah yang bisa kita tinggali.
Dari cetakan tersebut kita bisa membuat:
Rumah 1
Rumah 2
Rumah 3
Rumah 4
Semua rumah memiliki struktur yang sama, tetapi datanya bisa berbeda.
Begitu juga dengan class.
Misalnya:
class Student {
late String name;
late int age;
late int roleNumber;
}
Class Student menentukan bahwa setiap object Student memiliki:
nameageroleNumber
Tetapi class tersebut belum menjadi siswa tertentu.
3. Cara membuat Class di Dart
Sintaks dasarnya:
class NamaClass {
}
Contoh:
class Student {
}
Kemudian kita bisa memasukkan properties/fields ke dalamnya:
class Student {
late String name;
late int roleNumber;
late int age;
}
Di sini:
String name;
int roleNumber;
int age;
adalah properties/fields dari class.
4. Kenapa nama Class menggunakan huruf kapital?
Dalam Dart, konvensi penamaan class menggunakan PascalCase.
Artinya setiap kata diawali huruf kapital.
Contoh:
class Student {
}
Benar.
class BankAccount {
}
Benar.
class UserProfile {
}
Benar.
class ShoppingCart {
}
Benar.
Kalau terdiri dari dua kata:
BankAccount
↑
Bank = B besar
Account = A besar
Bukan:
class bankAccount {}
atau:
class bankaccount {}
Walaupun beberapa bentuk mungkin tetap diterima oleh bahasa, kita sebaiknya mengikuti konvensi Dart.
Ingat:
Nama class → PascalCase
Contoh:
Student
Person
Car
BankAccount
UserProfile
ProductItem
5. Property/Field dalam Class
Sekarang kita buat class Student:
class Student {
late String name;
late int roleNumber;
late int age;
}
Kita bisa membayangkan:
Student
│
├── name
├── roleNumber
└── age
Ketiga variable tersebut menjadi bagian dari object Student.
6. Kenapa menggunakan late?
Ini penting karena berkaitan dengan null safety Dart.
Misalnya kita menulis:
class Student {
String name;
int age;
}
Dart akan mengeluh karena:
variable
namedanagebelum diberikan nilai.
Kenapa?
Karena:
String
secara default berarti tidak boleh null.
Dart ingin memastikan bahwa:
name
selalu memiliki nilai String yang valid.
7. Cara pertama: menggunakan late
Kita bisa mengatakan kepada Dart:
“Tenang, nilai ini memang belum saya isi sekarang. Nanti akan saya isi.”
Caranya:
class Student {
late String name;
late int age;
}
late berarti kira-kira:
Variable ini akan diinisialisasi nanti.
Contoh:
class Student {
late String name;
late int age;
}
void main() {
Student student = Student();
student.name = "Budi";
student.age = 20;
print(student.name);
print(student.age);
}
Output:
Budi
20
Urutannya:
Student()
↓
object dibuat
↓
student.name = "Budi"
↓
student.age = 20
↓
print()
Hati-hati
Kalau kita menggunakan late, tetapi membaca variable sebelum memberikan nilai:
Student student = Student();
print(student.name);
bisa menghasilkan:
LateInitializationError
Jadi late bukan berarti “boleh kosong selamanya”.
Lebih tepat:
Nilainya belum ada sekarang, tetapi harus diberikan sebelum digunakan.
8. Cara kedua: menggunakan ?
Alternatifnya adalah membuat variable nullable:
class Student {
String? name;
int? age;
}
Tanda:
?
berarti variable tersebut boleh berisi null.
Contoh:
Student student = Student();
print(student.name);
Hasilnya bisa:
null
Jadi perbedaannya:
| Penulisan | Arti |
|---|---|
String name | Tidak boleh null |
String? name | Boleh null |
late String name | Belum diisi sekarang, tetapi nanti harus diisi |
9. Setelah Class dibuat, program langsung mencetak sesuatu?
Tidak.
Misalnya kita hanya membuat:
class Student {
late String name;
late int age;
void display() {
print("Name: $name");
print("Age: $age");
}
}
Kemudian:
void main() {
}
Tidak akan muncul output.
Kenapa?
Karena kita baru membuat cetakan.
Kita belum membuat object dan belum menjalankan method.
Ibaratnya:
Kita punya cetakan kue
↓
Tapi belum membuat kue
↓
Tidak ada kue yang bisa dimakan
10. Apa itu Object?
Object adalah instance dari sebuah class.
Ini definisi yang sangat penting.
Misalnya:
class Student {
late String name;
late int age;
}
Untuk membuat object:
Student student = Student();
Mari kita pecah:
Student student = Student();
Bagian pertama
Student
adalah type/class.
Sama seperti:
String name;
int age;
double height;
Student sekarang menjadi data type buatan kita sendiri.
Bagian kedua
student
adalah nama variable yang menyimpan object.
Bagian ketiga
Student()
digunakan untuk membuat instance/object dari class Student.
Jadi:
Student student = Student();
artinya:
Buat sebuah object dari class
Student, lalu simpan object tersebut di variablestudent.
11. Contoh lengkap Class dan Object
class Student {
late String name;
late int age;
late int roleNumber;
}
void main() {
Student student = Student();
student.name = "Budi";
student.age = 20;
student.roleNumber = 10;
print(student.name);
print(student.age);
print(student.roleNumber);
}
Output:
Budi
20
10
12. Apa fungsi tanda titik .?
Ini salah satu konsep penting dalam OOP.
Ketika kita menulis:
student.name
artinya:
Ambil/access
nameyang dimiliki oleh objectstudent.
Begitu juga:
student.age
atau:
student.roleNumber
Jadi tanda:
.
digunakan untuk mengakses member dari object.
Contoh:
student.name
student.age
student.display()
13. Object juga bisa memanggil Function/Method
Di dalam class kita bisa membuat function.
Contoh:
class Student {
late String name;
late int age;
void display() {
print("Name: $name");
print("Age: $age");
}
}
display() disebut method karena function tersebut berada di dalam class.
Kemudian:
void main() {
Student student = Student();
student.name = "Budi";
student.age = 20;
student.display();
}
Output:
Name: Budi
Age: 20
Perhatikan:
student.display();
Artinya:
Jalankan method
display()milik objectstudent.
14. Field vs Method
Di OOP kita akan sering bertemu dua istilah ini.
Field/Property
Menyimpan data.
late String name;
late int age;
Method
Melakukan aksi/perilaku.
void display() {
print(name);
}
Gambaran:
Student
│
├── DATA
│ ├── name
│ ├── age
│ └── roleNumber
│
└── BEHAVIOR
└── display()
Jadi:
Field = data yang dimiliki object
Method = tindakan yang bisa dilakukan object
15. Membuat method setData()
Dalam materi, dibuat function seperti:
void setData(String n, int r, int a) {
name = n;
roleNumber = r;
age = a;
}
Tujuannya adalah memberikan data kepada object.
Contoh class lengkap:
class Student {
late String name;
late int roleNumber;
late int age;
void setData(String n, int r, int a) {
name = n;
roleNumber = r;
age = a;
}
void display() {
print("Name: $name");
print("Role Number: $roleNumber");
print("Age: $age");
}
}
Kemudian:
void main() {
Student student = Student();
student.setData("Budi", 10, 20);
student.display();
}
Output:
Name: Budi
Role Number: 10
Age: 20
16. Apa yang sebenarnya terjadi ketika setData() dipanggil?
Ketika kita menulis:
student.setData("Budi", 10, 20);
parameter menerima:
n = "Budi"
r = 10
a = 20
Kemudian:
name = n;
menjadi:
name = "Budi";
Lalu:
roleNumber = r;
menjadi:
roleNumber = 10;
Dan:
age = a;
menjadi:
age = 20;
Sehingga object sekarang memiliki:
student
├── name = "Budi"
├── roleNumber = 10
└── age = 20
Kemudian:
student.display();
mencetak data tersebut.
17. Membuat lebih dari satu Object
Ini salah satu keuntungan besar dari class.
Kita bisa membuat:
Student student1 = Student();
Student student2 = Student();
Student student3 = Student();
Ketiganya berasal dari class yang sama.
Tetapi datanya bisa berbeda.
student1.setData("Budi", 10, 20);
student2.setData("Andi", 11, 21);
student3.setData("Citra", 12, 19);
Sekarang:
Student class
│
├── student1
│ ├── Budi
│ ├── 10
│ └── 20
│
├── student2
│ ├── Andi
│ ├── 11
│ └── 21
│
└── student3
├── Citra
├── 12
└── 19
Class-nya sama.
Object-nya berbeda.
Data setiap object juga berbeda.
18. Ini alasan kenapa OOP berguna
Bayangkan kita punya 1.000 siswa.
Tanpa OOP, kita bisa saja membuat variable:
String student1Name;
int student1Age;
String student2Name;
int student2Age;
String student3Name;
int student3Age;
Ini cepat menjadi berantakan.
Dengan class:
class Student {
late String name;
late int age;
}
kita cukup membuat object:
Student student1 = Student();
Student student2 = Student();
Student student3 = Student();
Struktur data siswa menjadi lebih rapi.
19. Memisahkan Class ke File Berbeda
Dalam program kecil, kita bisa menulis semuanya dalam satu file.
Misalnya:
main.dart
berisi:
class Student {
...
}
class Person {
...
}
class Area {
...
}
void main() {
...
}
Tetapi kalau program semakin besar, file akan menjadi sangat panjang.
Maka kita bisa memisahkannya:
project/
│
├── main.dart
├── student.dart
├── person.dart
└── area.dart
Ini merupakan praktik yang sangat umum.
20. File student.dart
Misalnya:
class Student {
late String name;
late int age;
void setData(String n, int a) {
name = n;
age = a;
}
void display() {
print("Name: $name");
print("Age: $age");
}
}
Kemudian main.dart ingin menggunakan class tersebut.
Kita import:
import 'student.dart';
Lalu:
void main() {
Student student = Student();
student.setData("Budi", 20);
student.display();
}
21. Apa sebenarnya fungsi import?
import berarti kira-kira:
“Dart, saya ingin menggunakan isi dari file/library ini di file saya.”
Contoh:
import 'student.dart';
Artinya main.dart ingin menggunakan sesuatu yang didefinisikan di student.dart.
Tanpa import, Dart tidak otomatis mengetahui class Student yang ada di file tersebut.
22. Kenapa cukup menulis student.dart?
Karena misalnya:
project/
├── main.dart
└── student.dart
Kedua file berada di folder yang sama.
Jadi:
import 'student.dart';
cukup.
Kalau file berada di folder lain:
project/
├── main.dart
└── models/
└── student.dart
maka path-nya perlu disesuaikan:
import 'models/student.dart';
Jadi prinsipnya:
Path pada
importharus menunjukkan lokasi file yang ingin digunakan.
23. Contoh Person
Materi kemudian membuat file:
person.dart
Isinya:
class Person {
late String name;
late int age;
void setValues(String n, int a) {
name = n;
age = a;
}
void display() {
print("Name: $name");
print("Age: $age");
}
}
Kemudian di main.dart:
import 'person.dart';
void main() {
Person person = Person();
person.setValues("Budi", 20);
person.display();
}
Output:
Name: Budi
Age: 20
24. Sekarang bagian yang sangat penting: this
Ini bagian yang biasanya membuat pemula bingung.
Misalnya kita punya:
class Area {
late num width;
late num height;
void setValues(num width, num height) {
this.width = width;
this.height = height;
}
}
Kenapa ada:
this.width
dan:
width
Padahal namanya sama?
Karena keduanya menunjuk ke hal yang berbeda.
25. Memahami this
this berarti:
object/class yang sedang digunakan saat ini.
Misalnya:
this.width
artinya:
widthmilik object/class ini.
Sedangkan:
width
bisa merujuk kepada parameter method.
Jadi:
void setValues(num width, num height) {
this.width = width;
this.height = height;
}
sebenarnya berarti:
this.width
↑
property milik object
width
↑
parameter function
26. Kenapa tidak cukup width = width?
Misalnya:
void setValues(num width, num height) {
width = width;
height = height;
}
Ini bermasalah secara logika.
Dart akan melihat width sebagai parameter lokal dalam konteks tersebut, sehingga kita tidak secara jelas menunjuk field object.
Dengan:
this.width = width;
kita mengatakan dengan jelas:
property object = parameter
atau:
this.width = width;
dibaca:
“Masukkan nilai parameter
widthke propertywidthmilik object ini.”
27. Analogi this
Bayangkan kamu sedang berkata:
“Barang saya = barang yang diberikan kepada saya.”
Dalam kode:
this.width = width;
kurang lebih:
this.width
↓
lebar milik SAYA
width
↓
lebar yang DIBERIKAN
Jadi:
this.width = width
↓ ↓
milik parameter
object method
28. Contoh Class Area
Kita buat:
class Area {
late num width;
late num height;
void setValues(num width, num height) {
this.width = width;
this.height = height;
}
void calculateArea() {
num area = width * height;
print("Area: $area");
}
}
Kemudian:
void main() {
Area area = Area();
area.setValues(25, 56);
area.calculateArea();
}
Perhitungannya:
width = 25
height = 56
area = width × height
= 25 × 56
= 1400
Jadi output yang benar untuk 25 × 56 adalah:
Area: 1400
Catatan: caption menyebut hasil 9060, tetapi itu tidak sesuai dengan angka 25 dan 56. Jika angkanya memang 25 dan 56, hasilnya 1400.
29. Alur program Area
Mari kita ikuti dari awal.
Langkah 1 — Class dibuat
class Area {
late num width;
late num height;
}
Belum ada object.
Langkah 2 — Object dibuat
Area area = Area();
Sekarang ada object:
area
├── width
└── height
Langkah 3 — Set nilai
area.setValues(25, 56);
Method:
void setValues(num width, num height) {
this.width = width;
this.height = height;
}
Hasil:
area
├── width = 25
└── height = 56
Langkah 4 — Hitung
area.calculateArea();
Method:
num result = width * height;
Maka:
25 × 56 = 1400
30. Class bisa memiliki Data + Behavior
Ini inti OOP yang harus kamu pahami.
Misalnya:
class BankAccount {
late String owner;
late num balance;
void deposit(num amount) {
balance += amount;
}
void withdraw(num amount) {
balance -= amount;
}
}
Class BankAccount memiliki:
Data
owner
balance
Behavior
deposit()
withdraw()
Jadi kita menggabungkan data dan operasi yang berhubungan dengan data tersebut dalam satu tempat.
Ini salah satu alasan OOP membuat program lebih terorganisir.
31. Class vs Object — jangan tertukar
Ini bagian yang sangat penting.
Misalnya:
class Car {
String brand = "";
}
Car adalah class.
Kemudian:
Car car1 = Car();
Car car2 = Car();
car1 dan car2 adalah object.
Jadi:
Car
↓
CLASS
car1
↓
OBJECT
car2
↓
OBJECT
Keduanya dibuat berdasarkan class yang sama.
32. Analogi yang sangat mudah
Bayangkan class = resep nasi goreng.
Resep menentukan:
Nasi
Telur
Kecap
Bumbu
Tetapi resep bukan makanan yang bisa dimakan.
Dari resep itu kita bisa membuat:
Nasi goreng 1
Nasi goreng 2
Nasi goreng 3
Dalam OOP:
CLASS
Student
↓
├── Object student1
├── Object student2
└── Object student3
Semua object mengikuti struktur class yang sama.
33. Kenapa satu class bisa punya banyak object?
Karena class adalah template yang bisa digunakan berkali-kali.
Contoh:
Student budi = Student();
Student andi = Student();
Student citra = Student();
Semuanya berasal dari:
class Student
Tetapi masing-masing menyimpan data sendiri.
budi
name = "Budi"
age = 20
andi
name = "Andi"
age = 21
citra
name = "Citra"
age = 19
Kalau kita mengubah:
budi.name = "Budi Santoso";
tidak otomatis mengubah:
andi.name
Karena mereka adalah object yang berbeda.
34. Ringkasan semua kode penting
Class sederhana
class Student {
late String name;
late int age;
}
Membuat object
Student student = Student();
Mengisi property
student.name = "Budi";
student.age = 20;
Mengakses property
print(student.name);
print(student.age);
Membuat method
void display() {
print(name);
print(age);
}
Memanggil method
student.display();
Method dengan parameter
void setData(String n, int a) {
name = n;
age = a;
}
Memanggil method dengan parameter
student.setData("Budi", 20);
Menggunakan this
void setData(String name, int age) {
this.name = name;
this.age = age;
}
Import class dari file lain
import 'student.dart';
35. Struktur project yang rapi
Untuk project yang lebih besar, kita bisa membuat:
my_project/
│
├── main.dart
│
├── student.dart
│
├── person.dart
│
└── area.dart
Misalnya student.dart:
class Student {
late String name;
late int age;
void display() {
print("Name: $name");
print("Age: $age");
}
}
person.dart:
class Person {
late String name;
late int age;
void display() {
print("Name: $name");
print("Age: $age");
}
}
area.dart:
class Area {
late num width;
late num height;
void setValues(num width, num height) {
this.width = width;
this.height = height;
}
void calculateArea() {
print(width * height);
}
}
Kemudian main.dart:
import 'student.dart';
import 'person.dart';
import 'area.dart';
void main() {
Student student = Student();
student.name = "Budi";
student.age = 20;
student.display();
Person person = Person();
person.name = "Andi";
person.age = 25;
person.display();
Area area = Area();
area.setValues(25, 56);
area.calculateArea();
}
Ini jauh lebih mudah dikelola daripada memasukkan ratusan class ke satu file.
36. Hal paling penting dari materi ini
Kalau kamu ingin mengingat materi ini dengan sederhana, ingat 7 poin berikut:
1. Class
class Student {}
Class = cetakan/template.
2. Object
Student student = Student();
Object = instance/hasil yang dibuat dari class.
3. Property/Field
late String name;
late int age;
Property = data yang dimiliki object.
4. Method
void display() {
print(name);
}
Method = aksi/perilaku object.
5. Dot .
student.name
student.display()
. = digunakan untuk mengakses member object.
6. this
this.name = name;
this = menunjuk kepada object/class yang sedang aktif.
7. import
import 'student.dart';
import = memungkinkan kita menggunakan isi file Dart lain.
37. Mental model yang sebaiknya kamu pegang
Kalau nanti kamu melihat kode seperti ini:
class Student {
late String name;
late int age;
void setData(String name, int age) {
this.name = name;
this.age = age;
}
void display() {
print(name);
print(age);
}
}
Bayangkan:
CLASS
┌───────────┐
│ Student │
├───────────┤
│ name │ ← data
│ age │ ← data
├───────────┤
│ setData() │ ← behavior
│ display() │ ← behavior
└─────┬─────┘
│
dibuat menjadi
↓
┌──────────────┐
│ student │
├──────────────┤
│ name = Budi │
│ age = 20 │
└──────────────┘
Jadi saat menulis:
student.setData("Budi", 20);
kita sedang menyuruh object student menjalankan behavior setData().
Saat menulis:
student.display();
kita menyuruh object tersebut menjalankan display().
Kesimpulan
Materi ini sebenarnya sedang membangun fondasi OOP:
CLASS
↓
template/cetakan
↓
OBJECT
↓
memiliki DATA + BEHAVIOR
↓
DATA → properties/fields
AKSI → methods
↓
object.property
object.method()
Dan kalau class sudah mulai banyak:
main.dart
│
├── import student.dart
├── import person.dart
└── import area.dart
Sehingga setiap class bisa disimpan di file masing-masing.
Kalimat yang paling penting untuk dihafal:
Class adalah cetakan, object adalah instance dari cetakan tersebut. Property menyimpan data, method melakukan aksi,
thismenunjuk ke object saat ini, danimportmemungkinkan kita menggunakan class dari file lain.