Materi ini mulai masuk ke inti Object-Oriented Programming (OOP) di Dart, yaitu class dan object. Konsep ini sangat penting dalam Flutter karena hampir semua hal yang kamu gunakan di Flutter berkaitan dengan object dan class.

Saya akan jelaskan dari paling dasar, lalu kita bedah contoh Person, termasuk apa yang sebenarnya terjadi di memory ketika membuat p1 dan p2.

Catatan: transcript memiliki beberapa kesalahan hasil speech-to-text, misalnya getters and setters terdengar seperti “gators and status”, height/age tertukar, dan beberapa nama method berubah. Saya akan gunakan istilah dan kode Dart yang benar.

1. Apa Itu Class?

Class adalah blueprint/cetakan/template untuk membuat object.

Bayangkan kamu ingin membangun rumah.

Sebelum membangun rumah, biasanya kamu mempunyai gambar rancangan:

          BLUEPRINT RUMAH

       ┌───────────────┐
       │     KAMAR     │
       │               │
       ├───────┬───────┤
       │ DAPUR │ RUANG │
       │       │ TAMU  │
       └───────┴───────┘

Blueprint tersebut bukan rumah sebenarnya.

Blueprint hanya menjelaskan:

• ada berapa kamar
• ada pintu
• ada jendela
• ukuran ruangan
• struktur rumah

Nah, dalam programming:

Blueprint
    ↓
  CLASS
    ↓
Object yang dibuat berdasarkan blueprint

2. Apa Itu Object?

Object adalah instance dari sebuah class.

Kalau class adalah blueprint rumah:

Class
 ↓
Blueprint rumah

maka object adalah rumah yang benar-benar dibangun:

Class
 ↓
Object 1 → Rumah A
Object 2 → Rumah B
Object 3 → Rumah C

Ketiga rumah tersebut bisa dibuat berdasarkan blueprint yang sama.

Dalam Dart:

class Person {
  String? name;
  int? age;
}

Person adalah class.

Kemudian:

Person p1 = Person();
Person p2 = Person();

p1 dan p2 adalah object/reference yang merujuk ke object Person.

3. Class dan Object Hubungannya

Cara paling mudah mengingat:

Class = cetakan Object = hasil yang dibuat dari cetakan

Contoh:

CLASS
Person
│
├── name
├── age
├── saveData()
└── showData()

          ↓ dibuat menjadi

OBJECT
p1
├── name = "Sam"
└── age = 24

OBJECT
p2
├── name = "Mark"
└── age = 32

Class-nya sama.

Tetapi object-nya bisa mempunyai data yang berbeda.

4. Contoh Dunia Nyata

Misalnya kita membuat aplikasi sekolah.

Kita mempunyai banyak siswa.

Setiap siswa mempunyai:

• nama
• umur
• nomor siswa
• nilai
• alamat

Dan siswa bisa melakukan sesuatu:

• belajar
• mengerjakan tugas
• mengikuti ujian

Dalam programming, kita bisa membuat:

class Student {
  String name;
  int age;

  void study() {
    print("$name sedang belajar");
  }
}

Di sini:

Student

adalah class.

Sedangkan:

Student student1 = Student(...);
Student student2 = Student(...);

adalah object yang dibuat dari class tersebut.

5. Class Berisi Data dan Behavior

Salah satu konsep paling penting dalam OOP adalah:

Object mempunyai data dan behavior.

Dalam Dart, data biasanya direpresentasikan oleh:

fields/properties

Sedangkan behavior direpresentasikan oleh:

methods

Contoh:

class Person {
  String? name;
  int? age;

  void sayHello() {
    print("Hello");
  }
}

Di sini:

String? name;
int? age;

adalah fields.

Sedangkan:

void sayHello() {
  print("Hello");
}

adalah method.

6. Apa Itu Field?

Field adalah variable yang menjadi bagian dari object/class.

Contoh:

class Person {
  String? name;
  int? age;
}

Ada dua field:

name
age

Setiap object Person mempunyai data tersebut sendiri.

Misalnya:

p1
├── name = "Sam"
└── age = 24

p2
├── name = "Mark"
└── age = 32

Walaupun berasal dari class yang sama, datanya berbeda.

7. Apa Itu Method?

Method adalah function yang berada di dalam class.

Misalnya:

class Person {
  String? name;
  int? age;

  void showData() {
    print("Name = $name");
    print("Age = $age");
  }
}

showData() adalah method, bukan biasanya disebut function biasa.

Kenapa?

Karena showData() berada di dalam class:

Person
│
├── name
├── age
└── showData()

8. Function vs Method

Sebelumnya kamu sudah belajar function.

Function biasa:

void sayHello() {
  print("Hello");
}

Kalau function tersebut berada di dalam class:

class Person {
  void sayHello() {
    print("Hello");
  }
}

kita biasanya menyebutnya method.

Jadi gampangnya:

Function
└── function yang berdiri sendiri

Method
└── function yang menjadi bagian dari class/object

9. Syntax Membuat Class

Bentuk dasar class Dart:

class NamaClass {
  // fields

  // methods

  // constructors
}

Contoh:

class Person {
  String? name;
  int? age;

  void sayHello() {
    print("Hello");
  }
}

Perhatikan:

class Person

class adalah keyword Dart.

Sedangkan:

Person

adalah nama class.

10. Kenapa Nama Class Huruf Besar?

Dalam Dart, konvensi penamaan class menggunakan UpperCamelCase.

Contoh:

class Person {}
class Student {}
class BankAccount {}
class UserProfile {}

Untuk nama yang terdiri dari beberapa kata:

class StudentProfile {}

bukan:

class studentProfile {}

atau:

class student_profile {}

Jadi biasakan:

Person
Student
BankAccount
UserProfile

11. Membuat Object dari Class

Misalnya kita sudah punya:

class Person {
  String? name;
  int? age;
}

Untuk membuat object:

Person p1 = Person();

Mari kita pecahkan:

Person

yang pertama:

tipe variable

p1

adalah:

nama variable/reference

Person()

adalah:

pemanggilan constructor untuk membuat object

Jadi:

Person p1 = Person();

secara sederhana berarti:

“Buat sebuah object Person, lalu simpan referensinya di p1.”

12. new di Dart

Transcript juga menunjukkan:

Person p1 = new Person();

Ini dulu sangat umum digunakan.

Tetapi dalam Dart modern, new tidak perlu ditulis.

Jadi:

Person p1 = Person();

sudah cukup.

Keduanya secara konsep sama:

Person p1 = Person();

dan:

Person p1 = new Person();

Namun gaya Dart modern biasanya memilih:

Person p1 = Person();

13. Apa Itu Constructor?

Perhatikan:

Person();

Bagian:

Person()

adalah constructor invocation.

Constructor digunakan ketika kita membuat object.

Misalnya:

class Person {
  String? name;
  int? age;
}

Kemudian:

Person p1 = Person();

Dart menggunakan constructor default yang tersedia.

Nanti kita akan belajar constructor secara khusus karena konsep ini sangat penting dalam Flutter.

14. Kenapa name dan age Error?

Transcript memberikan contoh:

class Person {
  String name;
  int age;
}

Dalam Dart dengan sound null safety, ini bermasalah.

Kenapa?

Karena:

String name;

berarti:

name tidak boleh null.

Dan:

int age;

berarti:

age tidak boleh null.

Tetapi saat object baru dibuat:

Person p1 = Person();

Dart harus tahu:

name = ?
age = ?

Nilai apa yang akan digunakan?

Karena belum ada nilai, field non-nullable tersebut belum diinisialisasi.

15. Solusi Pertama: Jadikan Nullable

Kita bisa menulis:

class Person {
  String? name;
  int? age;
}

Tanda:

?

berarti nilai tersebut boleh null.

Sehingga ketika object dibuat:

Person p1 = Person();

secara konsep:

p1
├── name = null
└── age = null

Kemudian nanti kita bisa mengisinya.

16. Solusi Kedua: Gunakan Constructor

Cara yang lebih umum dan bagus adalah memastikan field mendapatkan nilai saat object dibuat.

Misalnya:

class Person {
  String name;
  int age;

  Person(this.name, this.age);
}

Kemudian:

Person p1 = Person("Sam", 24);

Sekarang tidak ada masalah.

Karena saat object dibuat:

name = "Sam"
age = 24

Jadi field non-nullable sudah mempunyai nilai.

17. Solusi Ketiga: late

Kita juga bisa menggunakan:

class Person {
  late String name;
  late int age;
}

late berarti:

“Variable ini non-nullable, tetapi saya akan menginisialisasinya nanti.”

Kemudian:

Person p1 = Person();

p1.name = "Sam";
p1.age = 24;

Tetapi hati-hati.

Kalau kita melakukan:

Person p1 = Person();

print(p1.name);

sebelum name diisi, akan terjadi runtime error karena late belum diinisialisasi.

Jadi late harus digunakan dengan benar.

18. Contoh dari Transcript

Transcript menggunakan pendekatan nullable.

Kita bisa menulis:

class Person {
  String? name;
  int? age;

  void saveData(String n, int a) {
    name = n;
    age = a;
  }

  void showData() {
    print("Name = $name");
    print("Age = $age");
  }
}

Mari kita pahami bagian ini.

19. Method saveData()

Kita mempunyai:

void saveData(String n, int a) {
  name = n;
  age = a;
}

Method ini menerima dua parameter:

n
a

Kemudian:

name = n;
age = a;

Artinya:

Nilai parameter n dimasukkan ke field name.

Dan:

Nilai parameter a dimasukkan ke field age.

Misalnya:

p1.saveData("Sam", 24);

maka:

n = "Sam"
a = 24

kemudian:

name = "Sam"
age = 24

20. Kenapa Bisa Menulis name = n?

Ini penting.

name:

String? name;

adalah field milik object.

Sedangkan n:

String n

adalah parameter method.

Jadi:

name = n;

berarti:

field object = parameter

Contoh:

name = "Sam"

21. Method showData()

Kemudian:

void showData() {
  print("Name = $name");
  print("Age = $age");
}

Method ini mengambil data yang sudah tersimpan di object dan menampilkannya.

Misalnya object mempunyai:

name = "Sam"
age = 24

maka:

p1.showData();

menghasilkan:

Name = Sam
Age = 24

22. Membuat Object p1

Di main():

void main() {
  Person p1 = Person();

  p1.saveData("Sam", 24);

  p1.showData();
}

Output:

Name = Sam
Age = 24

Mari kita ikuti.

Langkah 1

Person p1 = Person();

Membuat object.

p1
 ↓
Person object

Awalnya:

name = null
age = null

Langkah 2

p1.saveData("Sam", 24);

Mengubah data object:

name = "Sam"
age = 24

Langkah 3

p1.showData();

Menampilkan:

Name = Sam
Age = 24

23. Membuat Object Kedua p2

Sekarang:

Person p2 = Person();

Ini membuat object baru.

Jadi sekarang ada dua object:

p1 → Person object #1

p2 → Person object #2

Keduanya berasal dari class yang sama.

Tetapi object-nya berbeda.

24. p1 dan p2 Tidak Berbagi Field yang Sama

Misalnya:

Person p1 = Person();
Person p2 = Person();

p1.saveData("Sam", 24);
p2.saveData("Mark", 32);

Hasilnya:

p1
├── name = "Sam"
└── age = 24

p2
├── name = "Mark"
└── age = 32

Kemudian:

p1.showData();
p2.showData();

Output:

Name = Sam
Age = 24

Name = Mark
Age = 32

Mengapa berbeda?

Karena setiap object mempunyai instance fields sendiri.

25. Apa Maksud “Instance Variable”?

Ini istilah yang sering muncul.

Misalnya:

class Person {
  String? name;
  int? age;
}

name dan age disebut instance variables/instance fields karena setiap instance/object Person mempunyai salinan field tersebut.

Secara sederhana:

Class Person
      │
      ├───────────────┐
      ↓               ↓
   Object p1       Object p2
   name            name
   age             age

Data p1 tidak otomatis menjadi data p2.

26. Memahami p1 sebagai Reference

Bagian transcript mengenai “address/hash code” perlu sedikit diluruskan.

Ketika kita menulis:

Person p1 = Person();

p1 adalah variable yang menyimpan reference ke object.

Secara sederhana kamu bisa membayangkan:

p1
 ↓
┌──────────────┐
│ Person object│
│              │
│ name = null  │
│ age = null   │
└──────────────┘

Kemudian:

Person p2 = Person();

akan membuat object lain:

p1 ──→ Object #1
       name = null
       age = null

p2 ──→ Object #2
       name = null
       age = null

Jadi p1 dan p2 menunjuk ke object yang berbeda.

27. Apa Itu Reference?

Bayangkan ada dua rumah:

Rumah A
Alamat: Jalan Mawar 10

Rumah B
Alamat: Jalan Melati 20

Variable bisa dianggap seperti kertas yang menyimpan “petunjuk” menuju rumah.

p1 → Rumah A
p2 → Rumah B

Dalam Dart, kita lebih tepat berbicara tentang reference ke object, bukan mengandalkan pemahaman bahwa variable Dart selalu menyimpan “alamat memory” mentah atau hash code.

Jadi untuk pemula:

p1 adalah reference yang memungkinkan kita mengakses object Person tertentu.

28. Apa Arti p1.saveData()?

Perhatikan:

p1.saveData("Sam", 24);

Bagian:

p1

adalah object/reference yang ingin digunakan.

Bagian:

.

adalah member access.

Bagian:

saveData(...)

adalah method yang dipanggil.

Jadi:

p1.saveData()

berarti:

“Panggil method saveData() pada object yang dirujuk oleh p1.”

29. p1.showData() dan p2.showData()

Misalnya:

p1.saveData("Sam", 24);
p2.saveData("Mark", 32);

Kemudian:

p1.showData();

yang digunakan adalah data milik object p1.

Sedangkan:

p2.showData();

yang digunakan adalah data milik object p2.

Sehingga:

p1.showData()
      ↓
Object #1
      ↓
Sam, 24

p2.showData()
      ↓
Object #2
      ↓
Mark, 32

30. Program Lengkap

Versi yang mengikuti konsep dari transcript:

class Person {
  String? name;
  int? age;

  void saveData(String n, int a) {
    name = n;
    age = a;
  }

  void showData() {
    print("Name = $name");
    print("Age = $age");
  }
}

void main() {
  Person p1 = Person();

  p1.saveData("Sam", 24);
  p1.showData();

  Person p2 = Person();

  p2.saveData("Mark", 32);
  p2.showData();
}

Output:

Name = Sam
Age = 24
Name = Mark
Age = 32

31. Alur Program Secara Visual

Saat:

Person p1 = Person();

terjadi:

             CLASS
            Person
              │
              │ membuat
              ▼
       ┌───────────────┐
p1 ───→│ Person Object │
       │               │
       │ name = null   │
       │ age  = null   │
       └───────────────┘

Kemudian:

p1.saveData("Sam", 24);

menjadi:

       ┌───────────────┐
p1 ───→│ Person Object │
       │               │
       │ name = "Sam"  │
       │ age  = 24     │
       └───────────────┘

Kemudian:

p1.showData();

membaca:

name → Sam
age  → 24

32. Saat p2 Dibuat

Kemudian:

Person p2 = Person();

dibuat object baru:

p1 ───→ Object #1
        name = "Sam"
        age = 24

p2 ───→ Object #2
        name = null
        age = null

Setelah:

p2.saveData("Mark", 32);

menjadi:

p1 ───→ Object #1
        name = "Sam"
        age = 24

p2 ───→ Object #2
        name = "Mark"
        age = 32

Inilah konsep multiple objects from one class.

33. Class sebagai User-Defined Type

Transcript mengatakan:

class adalah user-defined data type.

Ini adalah cara sederhana yang bagus untuk memahaminya.

Misalnya Dart sudah menyediakan:

int
String
double
bool
List
Map

Kemudian kita membuat sendiri:

class Person {}

Sekarang kita mempunyai tipe:

Person

Kita bisa membuat variable:

Person p1;
Person p2;
Person p3;

Jadi kita bisa menganggap:

Class memungkinkan kita membuat tipe data sendiri yang sesuai dengan kebutuhan aplikasi.

34. Class Menggabungkan Data dan Behavior

Misalnya tanpa class, kita mungkin mempunyai:

String name;
int age;

void saveData(...) {}
void showData() {}

Data dan function terpisah.

Dengan class:

class Person {
  String? name;
  int? age;

  void saveData(...) {}

  void showData() {}
}

Semuanya dikumpulkan dalam satu struktur:

Person
│
├── Data
│   ├── name
│   └── age
│
└── Behavior
    ├── saveData()
    └── showData()

Inilah salah satu inti OOP.

35. Encapsulation

Transcript juga menyebut istilah encapsulation.

Secara sederhana:

Encapsulation adalah menggabungkan data dan behavior yang berkaitan dalam satu unit/class, sekaligus mengatur bagaimana data tersebut diakses.

Misalnya:

class BankAccount {
  double balance = 0;

  void deposit(double amount) {
    balance += amount;
  }
}

Data:

balance

dan operasi terhadap data:

deposit()

diletakkan bersama dalam:

BankAccount

Dalam pembahasan OOP yang lebih lanjut, encapsulation juga berkaitan dengan kontrol akses dan menjaga invariant/data agar tidak sembarangan diubah.

36. Apakah Class Hanya Berisi Field dan Method?

Tidak.

Class Dart dapat mempunyai berbagai anggota, misalnya:

• instance fields
• static fields
• instance methods
• static methods
• constructors
• getters
• setters
• dan fitur lainnya

Untuk tahap sekarang, fokus dulu pada:

Class
 ↓
Fields
 ↓
Methods
 ↓
Constructor
 ↓
Objects

Itu fondasi yang sangat penting.

37. Instance vs Static

Transcript sempat menyebut:

static variable dan instance variable static method dan instance method

Untuk sekarang, pahami perbedaan dasarnya.

Instance field

Dimiliki oleh masing-masing object.

class Person {
  String? name;
}

Maka:

p1.name
p2.name

bisa berbeda.

Static field

Dimiliki oleh class, bukan masing-masing instance.

Contoh:

class Person {
  static int count = 0;
}

Diakses melalui class:

Person.count

Bukan:

p1.count

Untuk sekarang cukup ingat:

instance → milik object
static   → milik class

38. Contoh Analogi yang Lebih Kuat

Misalnya kita membuat class:

class Car {
  String? color;
  String? brand;

  void drive() {
    print("Mobil sedang berjalan");
  }
}

Class:

Car
│
├── color
├── brand
└── drive()

Kemudian:

Car car1 = Car();
Car car2 = Car();

Object:

car1
├── color = "Red"
├── brand = "Toyota"
└── drive()

car2
├── color = "Black"
├── brand = "Honda"
└── drive()

Blueprint sama.

Data object berbeda.

39. Hubungannya dengan Flutter

Ini sangat penting.

Flutter sangat banyak menggunakan class dan object.

Misalnya ketika kamu menulis:

Text("Hello")

Text adalah class dan kamu membuat instance/object dari class tersebut.

Ketika menulis:

Container(
  width: 100,
  height: 100,
)

kamu membuat object Container.

Begitu juga banyak widget Flutter:

Column(...)
Row(...)
Padding(...)
Text(...)
Scaffold(...)
AppBar(...)

Secara konsep:

Class
 ↓
Widget object
 ↓
Flutter menggunakannya untuk membangun UI

Jadi pemahaman class dan object bukan sekadar teori Dart.

Ini adalah fondasi utama Flutter.

40. Kenapa Flutter Penuh dengan Constructor?

Kamu akan sering melihat:

Text(
  "Hello",
)

atau:

Container(
  width: 100,
  height: 100,
)

Bentuk seperti:

Text(...)
Container(...)

adalah pemanggilan constructor untuk membuat object.

Nanti kita akan belajar constructor secara lebih mendalam, termasuk:

Text("Hello")

dan:

Container(
  width: 100,
  height: 100,
)

serta bagaimana required, named parameter, this, dan super bekerja.

41. Satu Hal Penting: Object Bukan Class

Jangan tertukar.

Misalnya:

class Person {}

Person adalah class.

Sedangkan:

Person p1 = Person();

object-nya adalah instance yang dibuat dari Person.

Secara sederhana:

Person
  ↓
CLASS / BLUEPRINT

Person()
  ↓
OBJECT / INSTANCE

p1
  ↓
REFERENCE KE OBJECT

Ini tiga hal yang berbeda.

42. Ringkasan Istilah

43. Pola yang Wajib Kamu Hafalkan

Untuk membuat class:

class Person {
  String? name;
  int? age;

  void sayHello() {
    print("Hello");
  }
}

Untuk membuat object:

Person p1 = Person();

Untuk mengakses field:

p1.name

Untuk mengubah field:

p1.name = "Sam";

Untuk memanggil method:

p1.sayHello();

Untuk membuat object kedua:

Person p2 = Person();

Sekarang:

p1 → object Person pertama
p2 → object Person kedua

44. Gambaran Besarnya

Kalau seluruh materi ini kita sederhanakan:

                 CLASS
              ┌───────────┐
              │  Person   │
              ├───────────┤
              │ name      │
              │ age       │
              ├───────────┤
              │ saveData()│
              │ showData()│
              └─────┬─────┘
                    │
           membuat object
              ┌─────┴─────┐
              ▼           ▼
          OBJECT p1    OBJECT p2
          ┌───────┐    ┌───────┐
          │ Sam   │    │ Mark  │
          │ 24    │    │ 32    │
          └───────┘    └───────┘

Satu class bisa digunakan untuk membuat banyak object.

Setiap object mempunyai instance fields-nya sendiri, tetapi mengikuti struktur dan behavior yang ditentukan oleh class.

45. Kesimpulan

Ada beberapa kalimat yang sebaiknya benar-benar kamu ingat:

1. Class adalah blueprint

Class = cetakan

Contoh:

class Person {}

2. Object adalah instance dari class

Person p1 = Person();

3. Field adalah data

String? name;
int? age;

4. Method adalah behavior/function di dalam class

void showData() {
  print(name);
}

5. Satu class bisa menghasilkan banyak object

Person p1 = Person();
Person p2 = Person();

6. p1 dan p2 bisa memiliki data berbeda

p1 → Sam, 24
p2 → Mark, 32

7. p1.method() berarti menjalankan method pada object yang dirujuk p1

p1.showData();

8. Person() adalah pemanggilan constructor

Person p1 = Person();

9. ? berarti nullable

String? name;

artinya name boleh berisi null.

10. new tidak perlu digunakan dalam Dart modern

Lebih umum:

Person p1 = Person();

daripada:

Person p1 = new Person();

Inti paling sederhananya

Bayangkan kamu membuat aplikasi sekolah.

Kamu membuat:

class Student {
  String? name;
  int? classNumber;

  void study() {
    print("$name sedang belajar");
  }
}

Student adalah blueprint.

Kemudian:

Student student1 = Student();
Student student2 = Student();

adalah dua object yang dibuat berdasarkan blueprint yang sama.

Kemudian:

student1.name = "Budi";
student2.name = "Andi";

hasilnya:

Student class
     │
     ├── student1
     │     └── name = Budi
     │
     └── student2
           └── name = Andi

Class menentukan bentuk dan kemampuan object. Object menyimpan data nyata berdasarkan class tersebut.

Dan inilah fondasi OOP yang akan sangat sering kamu lihat ketika mulai membuat aplikasi Flutter.