Video ini membahas cara mengakses static variable melalui object, tetapi ada satu hal penting yang perlu diluruskan: secara langsung Dart tidak mengizinkan kita mengakses static member melalui object. Video tersebut menggunakan instance method atau instance getter/setter sebagai “jembatan” untuk mengakses static variable.

Jadi inti videonya bukan:

object.staticVariable bisa langsung dilakukan.

Melainkan:

object.instanceMethod() → method tersebut mengakses static variable.

Mari kita bahas pelan-pelan.

1. Ingat dulu apa itu static

Misalkan kita punya:

class Test {
  static int count = 0;
}

Karena count diberi keyword static, maka count adalah milik class, bukan milik masing-masing object.

Kita mengaksesnya seperti ini:

print(Test.count);

Bukan:

Test t1 = Test();

print(t1.count); // ❌

Secara konsep:

             CLASS Test
                 │
          static count = 0
                 │
        ┌────────┴────────┐
        │                 │
       t1                t2
      object            object

count hanya satu, bukan satu untuk t1 dan satu untuk t2.

2. Masalah yang ingin diselesaikan video

Misalnya kita mempunyai:

class Test {
  static int count = 0;
}

Kita ingin melakukan sesuatu seperti:

Test t1 = Test();
Test t2 = Test();

t1.count = 10; // ❌

Dart tidak mengizinkan akses static member melalui instance seperti itu.

Cara normalnya:

Test.count = 10;

Dan mengambil nilainya:

print(Test.count);

Tetapi video bertanya:

Bagaimana kalau saya ingin mengakses count menggunakan t1 atau t2?

Jawabannya adalah dengan membuat instance method atau instance getter/setter sebagai perantara.

3. Teknik pertama: menggunakan instance method

Perhatikan kode berikut:

class Test {
  static int count = 0;

  int getCount() {
    return count;
  }

  void setCount(int value) {
    count = value;
  }
}

Mari kita pecah.

4. static int count = 0

static int count = 0;

Ini adalah static variable.

Artinya hanya ada satu count untuk class Test.

Secara konsep:

Test
└── count = 0

Bukan:

t1 → count = 0
t2 → count = 0

5. getCount() adalah instance method

Kita punya:

int getCount() {
  return count;
}

Perhatikan:

int getCount()

Tidak ada static.

Jadi getCount() adalah instance method.

Artinya untuk memanggilnya kita membutuhkan object:

Test t1 = Test();

t1.getCount();

Walaupun getCount() adalah milik object, isi method tersebut boleh mengakses static variable:

return count;

Karena count adalah static member dari class yang sama.

Secara konsep:

t1
 │
 └── getCount()
        │
        └── mengambil Test.count

Jadi t1 tidak memiliki count.

t1 hanya memiliki method getCount() yang mengambil nilai count.

6. setCount() juga instance method

Selanjutnya:

void setCount(int value) {
  count = value;
}

Method ini digunakan untuk mengubah static variable.

Misalnya:

t1.setCount(10);

Yang sebenarnya terjadi secara konsep:

t1.setCount(10)
      │
      ▼
Test.count = 10

Jadi t1 menjadi jalan untuk mengubah Test.count.

7. Program lengkap teknik pertama

Contohnya:

class Test {
  static int count = 0;

  int getCount() {
    return count;
  }

  void setCount(int value) {
    count = value;
  }
}

void main() {
  Test t1 = Test();
  Test t2 = Test();

  print(Test.count);

  t1.setCount(10);

  print(t2.getCount());

  print(Test.count);
}

Output:

0
10
10

Sekarang kita bahas kenapa hasilnya seperti itu.

8. Baris pertama

Test t1 = Test();

Kita membuat object pertama.

t1 → object Test

Kemudian:

Test t2 = Test();

Membuat object kedua.

t1 → object Test #1

t2 → object Test #2

Tetapi ingat:

count bukan milik t1 dan bukan milik t2.

count milik class:

Test
└── static count = 0

9. print(Test.count)

Kemudian:

print(Test.count);

Karena count adalah static, kita akses menggunakan nama class:

Test.count

Nilainya masih:

0

Maka output:

0

10. Kemudian t1.setCount(10)

Sekarang:

t1.setCount(10);

Kita memanggil instance method menggunakan object t1.

Method-nya:

void setCount(int value) {
  count = value;
}

Nilai value adalah:

10

Kemudian:

count = value;

berarti:

count = 10;

Karena count adalah static, maka yang berubah adalah:

Test.count

Sekarang:

Test
└── count = 10

11. Kenapa t2.getCount() juga menghasilkan 10?

Ini bagian paling penting.

Kita melakukan:

print(t2.getCount());

Mungkin pemula berpikir:

“Tapi kan yang mengubah count adalah t1. Kenapa t2 mendapatkan 10?”

Karena count bukan milik t1.

t1 hanya menjalankan:

setCount(10)

yang mengubah:

Test.count

Kemudian t2 menjalankan:

getCount()

yang mengambil:

Test.count

Jadi:

             Test
              │
        static count
              │
             10
              ▲
       ┌──────┴──────┐
       │             │
      t1             t2
       │             │
  setCount()      getCount()
       │             │
       └──────┬──────┘
              │
          Test.count

Itulah mengapa:

t2.getCount()

menghasilkan:

10

12. Test.count juga menghasilkan 10

Setelah itu:

print(Test.count);

Output:

10

Karena nilai static variable tadi sudah diubah:

count = 10

13. Kesimpulan teknik pertama

Video menggunakan dua instance method:

int getCount() {
  return count;
}

dan:

void setCount(int value) {
  count = value;
}

Sehingga kita bisa melakukan:

t1.setCount(10);

dan:

t2.getCount();

Walaupun sebenarnya yang diakses tetap:

Test.count

Jadi:

Object tidak mengakses static variable secara langsung. Object memanggil instance method yang kemudian mengakses static variable.

Ini penting sekali.

14. Teknik kedua: menggunakan getter dan setter

Sekarang video menggunakan cara yang lebih rapi.

Daripada:

t1.setCount(20);

dan:

t2.getCount();

kita bisa menggunakan getter dan setter.

Contohnya:

class Test {
  static int count = 0;

  int get countValue {
    return count;
  }

  set countValue(int value) {
    count = value;
  }
}

Sekarang ada dua hal:

get countValue

dan:

set countValue(int value)

15. Apa itu getter?

Getter adalah sesuatu yang terlihat seperti property ketika digunakan, tetapi sebenarnya menjalankan kode.

Kita membuat:

int get countValue {
  return count;
}

Ketika kita menulis:

t1.countValue

getter dijalankan.

Secara konsep:

t1.countValue
      │
      ▼
getter countValue
      │
      ▼
return count
      │
      ▼
Test.count

16. Apa itu setter?

Setter digunakan untuk memberikan nilai.

Kita membuat:

set countValue(int value) {
  count = value;
}

Kemudian kita bisa menulis:

t1.countValue = 20;

Perhatikan bentuknya.

Bukan:

t1.countValue(20);

Tetapi:

t1.countValue = 20;

Ketika Dart melihat assignment tersebut, setter dijalankan:

set countValue(int value) {
  count = value;
}

Sehingga:

t1.countValue = 20
        │
        ▼
setter
        │
        ▼
count = 20
        │
        ▼
Test.count = 20

17. Program lengkap teknik kedua

class Test {
  static int count = 0;

  int get countValue {
    return count;
  }

  set countValue(int value) {
    count = value;
  }
}

void main() {
  Test t1 = Test();
  Test t2 = Test();

  print(Test.count);

  t1.countValue = 20;

  print(t2.countValue);

  print(Test.count);
}

Output:

0
20
20

18. Kenapa t2.countValue bisa mendapatkan 20?

Karena lagi-lagi:

t1 dan t2

tidak mempunyai count masing-masing.

Ada satu:

Test.count

Urutannya:

Awalnya

Test.count = 0

t1.countValue = 20

Setter berjalan:

count = 20;

Sehingga:

Test.count = 20

t2.countValue

Getter berjalan:

return count;

dan count sekarang:

20

Maka hasilnya:

20

19. Perbedaan teknik pertama dan kedua

Teknik pertama

Menggunakan method biasa:

int getCount() {
  return count;
}

void setCount(int value) {
  count = value;
}

Pemakaian:

t1.setCount(20);

print(t2.getCount());

Teknik kedua

Menggunakan getter dan setter:

int get countValue {
  return count;
}

set countValue(int value) {
  count = value;
}

Pemakaian:

t1.countValue = 20;

print(t2.countValue);

Getter/setter terasa lebih seperti mengakses property.

20. Kenapa getter/setter terasa lebih natural?

Bandingkan:

Method

t1.setCount(20);

Untuk membaca:

t1.getCount();

Getter/setter

Untuk menulis:

t1.countValue = 20;

Untuk membaca:

print(t1.countValue);

Getter/setter membuat penggunaan terlihat seperti variable/property biasa, walaupun sebenarnya ada kode yang dijalankan di belakangnya.

21. Tapi apakah t1.count sekarang bisa?

Tidak.

Misalnya:

class Test {
  static int count = 0;
}

Kemudian:

Test t1 = Test();

print(t1.count); // ❌

Tetap tidak boleh.

Yang boleh:

print(Test.count);

Atau jika kita membuat getter:

class Test {
  static int count = 0;

  int get countValue => count;
}

maka:

Test t1 = Test();

print(t1.countValue); // ✅

Tetapi perhatikan:

t1.countValue

bukan:

t1.count

countValue adalah instance getter yang kita buat sebagai perantara.

22. Analogi sederhana

Bayangkan ada sebuah perusahaan bernama Test.

Perusahaan hanya mempunyai satu kas perusahaan:

Test
└── kas = Rp0

Kemudian ada dua pegawai:

Andi → t1
Budi → t2

Andi bisa meminta bagian administrasi untuk mengubah kas:

Andi → setCount(10)
           ↓
       kas perusahaan = 10

Kemudian Budi bisa meminta bagian administrasi membaca kas:

Budi → getCount()
           ↓
       kas perusahaan = 10

Budi mendapatkan:

10

Bukan karena Budi mempunyai kas sendiri, tetapi karena keduanya mengakses satu kas perusahaan yang sama.

Begitu juga dengan static variable.

23. Hal paling penting: static vs instance

Ini harus benar-benar dibedakan.

Instance variable

class Test {
  int count = 0;
}

Setiap object mempunyai count sendiri.

Test t1 = Test();
Test t2 = Test();

t1.count = 10;
t2.count = 20;

Hasil:

t1.count = 10
t2.count = 20

Karena:

t1 → count = 10

t2 → count = 20

Static variable

class Test {
  static int count = 0;
}

Hanya ada satu count.

Test
└── count = 0

Jika:

t1.setCount(10);

maka:

Test.count = 10

Kemudian:

t2.getCount();

hasilnya:

10

Karena tetap membaca Test.count.

24. Gambaran visual

Instance variable

Test class
   │
   ├── t1
   │    └── count = 10
   │
   └── t2
        └── count = 20

Ada dua count.

Static variable

Test class
   │
   └── static count = 20
          ▲
          │
       ┌──┴──┐
       │     │
      t1     t2

Hanya ada satu count.

25. Ada satu hal teknis yang perlu diluruskan dari video

Video mengatakan bahwa:

“It’s possible to access static variables through an object.”

Kalimat ini bisa membuat pemula salah paham.

Lebih tepatnya:

Dart tidak mengizinkan direct access terhadap static member melalui instance.

Contoh:

class Test {
  static int count = 0;
}

void main() {
  Test t1 = Test();

  print(t1.count); // ❌
}

Yang dilakukan video adalah membuat instance method/getter/setter sebagai perantara:

class Test {
  static int count = 0;

  int get countValue => count;

  set countValue(int value) {
    count = value;
  }
}

Kemudian:

t1.countValue = 20;
print(t1.countValue);

Ini valid karena:

t1
 │
 └── countValue
       │
       ├── getter/setter adalah instance member
       │
       └── mengakses static count

Jadi bukan t1 yang langsung mengakses static count.

26. Kenapa teknik seperti ini bisa berguna?

Misalnya kita mempunyai:

class Counter {
  static int count = 0;

  int get value => count;

  set value(int newValue) {
    count = newValue;
  }
}

Sekarang kita bisa:

final a = Counter();
final b = Counter();

a.value = 100;

print(b.value);

Output:

100

Karena:

a.value
   ↓
static Counter.count
   ↓
100

dan:

b.value
   ↓
static Counter.count
   ↓
100

27. Tetapi apakah teknik ini selalu disarankan?

Tidak selalu.

Kalau memang tujuan kita adalah mengakses static variable, biasanya cara paling sederhana adalah:

Counter.count

Tidak perlu membuat object hanya untuk mengaksesnya.

Misalnya:

class MathUtils {
  static int add(int a, int b) {
    return a + b;
  }
}

Kita cukup:

print(MathUtils.add(10, 20));

Tidak perlu:

final math = MathUtils();

28. Kapan getter/setter lebih masuk akal?

Getter dan setter lebih berguna ketika kita memang ingin memberikan interface/property kepada object.

Contoh:

class User {
  String _name = '';

  String get name => _name;

  set name(String value) {
    if (value.isNotEmpty) {
      _name = value;
    }
  }
}

Pemakaiannya:

final user = User();

user.name = "Budi";

print(user.name);

Di sini getter/setter memang sangat berguna karena kita bisa memberikan validasi:

set name(String value) {
  if (value.isNotEmpty) {
    _name = value;
  }
}

Jadi getter/setter bukan hanya “cara lain mengakses variable”, tetapi juga bisa digunakan untuk mengontrol bagaimana property dibaca atau diubah.

29. Hubungannya dengan private variable

Ini juga akan sering muncul nanti.

Misalnya:

class Counter {
  static int _count = 0;

  int get count => _count;

  set count(int value) {
    _count = value;
  }
}

Sekarang _count dibuat private terhadap library.

Pengguna class tidak mengakses _count secara langsung, tetapi melalui:

counter.count

Getter:

int get count => _count;

dan setter:

set count(int value) {
  _count = value;
}

Konsep ini sangat penting dalam encapsulation.

30. Ringkasan video

Video tersebut sebenarnya membahas dua cara membuat instance menjadi perantara untuk mengakses static variable.

Cara 1 — method biasa

class Test {
  static int count = 0;

  int getCount() {
    return count;
  }

  void setCount(int value) {
    count = value;
  }
}

Penggunaan:

final t1 = Test();
final t2 = Test();

t1.setCount(10);

print(t2.getCount()); // 10
print(Test.count);    // 10

Cara 2 — getter dan setter

class Test {
  static int count = 0;

  int get countValue => count;

  set countValue(int value) {
    count = value;
  }
}

Penggunaan:

final t1 = Test();
final t2 = Test();

t1.countValue = 20;

print(t2.countValue); // 20
print(Test.count);    // 20

31. Cheat sheet

Kalimat yang paling penting untuk diingat:

static member milik class, sedangkan instance member milik object.

Dan pada video ini:

Object bukan mengakses static variable secara langsung. Object memanggil instance method/getter/setter yang kemudian mengakses static variable.

Itulah alasan t1.setCount(10), t2.getCount(), dan Test.count semuanya pada akhirnya bekerja terhadap satu count yang sama.