Masukkan Password
44 Static Variable & Static Method in Dart | Use of static in Dart | Dart Tutorial
Transcript ini membahas static variable dan static method di Dart. Konsep ini cukup penting karena berkaitan dengan perbedaan antara milik object dan milik class.
Saya akan jelaskan dari dasar, lalu masuk ke aturan dan contoh, sekaligus meluruskan beberapa bagian transcript yang kurang tepat.
1. Gambaran besar: apa itu static?
Sebelum masuk kode, pahami satu kalimat ini:
Member biasa (
non-static) dimiliki oleh masing-masing object, sedangkan memberstaticdimiliki oleh class.
Misalnya kita punya:
class Person {
String name;
}
Kemudian:
Person p1 = Person();
Person p2 = Person();
Ada dua object:
p1 → Person Object #1
p2 → Person Object #2
Field:
String name;
adalah non-static.
Jadi setiap object mempunyai name sendiri:
p1
└── name = "Budi"
p2
└── name = "Andi"
Sekarang kalau kita membuat:
static int count = 0;
count bukan milik p1 atau p2.
Melainkan milik:
Person
↓
static count
2. Apa itu static variable?
Contoh:
class Test {
int x = 10;
static int y = 20;
}
Di sini ada dua field:
int x = 10;
dan:
static int y = 20;
x adalah instance field/non-static field.
y adalah static field.
3. Kenapa disebut instance field?
Karena x melekat pada instance/object.
Misalnya:
void main() {
Test obj1 = Test();
Test obj2 = Test();
}
Ada dua object:
obj1 → Test Object #1
obj2 → Test Object #2
Masing-masing mempunyai x sendiri:
obj1
└── x = 10
obj2
└── x = 10
Jadi secara konsep ada dua x.
4. Bagaimana dengan static field?
Untuk:
static int y = 20;
kita tidak membuat y untuk setiap object.
Konsepnya:
Test
└── static y = 20
Walaupun kita membuat:
Test obj1 = Test();
Test obj2 = Test();
Test obj3 = Test();
Test obj4 = Test();
tetap hanya ada satu static y yang terkait dengan class Test.
Secara sederhana:
Test
│
static y = 20
│
┌──────┼──────┐
↓ ↓ ↓
obj1 obj2 obj3
Object-object tersebut tidak mempunyai copy y masing-masing.
5. Kenapa static disebut “class member”?
Karena static member dikaitkan dengan class, bukan instance.
Misalnya:
class Bank {
static String bankName = "BCA";
}
Cara mengakses:
print(Bank.bankName);
Perhatikan:
Bank.bankName
bukan:
bank.bankName
6. Static variable harus diakses menggunakan nama class
Misalnya:
class Test {
static int y = 20;
}
Benar:
print(Test.y);
❌ Jangan:
Test obj = Test();
print(obj.y);
Dart akan menolak akses static member melalui instance.
Jadi pola utamanya:
instance member
↓
object.field
static member
↓
ClassName.field
7. Contoh yang lebih jelas
class Person {
String name = "";
static int totalPerson = 0;
}
Kemudian:
void main() {
Person p1 = Person();
Person p2 = Person();
p1.name = "Budi";
p2.name = "Andi";
Person.totalPerson = 2;
print(p1.name);
print(p2.name);
print(Person.totalPerson);
}
Output:
Budi
Andi
2
Perhatikan:
p1.name
p2.name
karena name adalah instance field.
Sedangkan:
Person.totalPerson
karena totalPerson adalah static field.
8. Analogi sederhana
Bayangkan sebuah sekolah.
Ada banyak siswa:
Siswa 1
Siswa 2
Siswa 3
Siswa 4
Setiap siswa mempunyai:
nama
umur
alamat
Ini adalah data masing-masing siswa.
Jadi:
class Student {
String name;
int age;
}
Tetapi sekolah juga mempunyai:
nama sekolah
alamat sekolah
jumlah siswa
Data seperti itu bisa bersifat sama untuk seluruh object.
Misalnya:
class Student {
String name;
static String schoolName = "SMAN 1";
}
Maka:
Student
└── schoolName = "SMAN 1"
p1 → name = "Budi"
p2 → name = "Andi"
p3 → name = "Citra"
name berbeda-beda, sedangkan schoolName dibagikan sebagai data class.
9. Static variable bisa diubah
Static bukan berarti immutable.
Misalnya:
class Counter {
static int count = 0;
}
Kita bisa:
Counter.count++;
print(Counter.count);
Output:
1
Kemudian:
Counter.count++;
print(Counter.count);
Output:
2
Jadi:
static
berarti kepemilikan/aksesnya terkait class, bukan berarti:
static = tidak bisa berubah
Kalau ingin tidak berubah, bisa kombinasikan dengan final:
static final String appName = "My App";
10. Static variable tidak membutuhkan object
Ini salah satu karakteristik paling penting.
Misalnya:
class MathConfig {
static double pi = 3.14159;
}
Kita bisa langsung:
print(MathConfig.pi);
Tidak perlu:
MathConfig obj = MathConfig();
Ini karena pi adalah member milik class.
Secara konsep:
Class
↓
static member
↓
bisa digunakan tanpa membuat instance
11. Sekarang masuk ke static method
Konsepnya sama.
Method biasa:
class Test {
void show() {
print("Hello");
}
}
show() adalah instance method.
Untuk menjalankannya:
Test obj = Test();
obj.show();
Karena method tersebut milik object.
12. Static method
Kalau kita menulis:
class Test {
static void show() {
print("Hello");
}
}
maka show() menjadi static method.
Sekarang kita bisa:
Test.show();
Tidak perlu:
Test obj = Test();
Jadi:
Instance method:
obj.show()
Static method:
Test.show()
13. Kenapa static method berguna?
Static method cocok ketika method tersebut:
Tidak membutuhkan data dari object tertentu.
Misalnya kita ingin membuat utility untuk menghitung luas:
class MathUtils {
static int square(int number) {
return number * number;
}
}
Kemudian:
void main() {
print(MathUtils.square(5));
}
Output:
25
Kita tidak perlu:
MathUtils obj = MathUtils();
karena method tersebut tidak membutuhkan state dari object.
14. Contoh utility class
Misalnya:
class Calculator {
static int add(int a, int b) {
return a + b;
}
static int multiply(int a, int b) {
return a * b;
}
static int subtract(int a, int b) {
return a - b;
}
}
Penggunaannya:
void main() {
print(Calculator.add(10, 20));
print(Calculator.multiply(5, 4));
print(Calculator.subtract(20, 7));
}
Output:
30
20
13
Tidak perlu membuat object:
Calculator calculator = Calculator();
15. Static method cocok untuk utility
Contohnya:
formatDate()
formatCurrency()
calculateTax()
convertTemperature()
validateEmail()
generateId()
calculateDistance()
Kalau fungsi tersebut tidak membutuhkan state dari instance tertentu, static method bisa menjadi pilihan.
Contoh:
class StringUtils {
static bool isEmpty(String value) {
return value.trim().isEmpty;
}
}
Pemakaian:
bool result = StringUtils.isEmpty(" ");
16. Perbedaan instance method dan static method
| Instance method | Static method |
|---|---|
| Milik object | Milik class |
| Perlu instance untuk dipanggil | Tidak perlu instance |
obj.show() | Test.show() |
| Bisa mengakses instance field | Tidak bisa mengakses instance field secara langsung |
Bisa menggunakan this | Tidak punya this |
17. Aturan paling penting: static method tidak bisa mengakses instance member
Misalnya:
class Test {
int x = 10;
static void show() {
print(x); // ❌
}
}
Kenapa error?
Karena x adalah instance field.
x baru ada pada object tertentu.
Sedangkan:
Test.show();
tidak mempunyai object tertentu.
Pertanyaannya:
xmilik object yang mana?
Tidak ada jawabannya.
18. Bayangkan ada dua object
class Test {
int x = 10;
static void show() {
print(x); // ❌
}
}
Misalnya:
Test obj1 = Test();
Test obj2 = Test();
obj1.x = 100;
obj2.x = 200;
Sekarang ada:
obj1 → x = 100
obj2 → x = 200
Kalau kita memanggil:
Test.show();
Dart harus bertanya:
show() mau mengambil x milik obj1?
atau
x milik obj2?
Tidak ada object yang dipilih.
Itulah alasan static method tidak dapat langsung mengakses instance field.
19. Static method boleh mengakses static member
Misalnya:
class Test {
static int x = 10;
static void show() {
print(x);
}
}
Ini valid.
Karena:
x
↓
static
show()
↓
static
Keduanya sama-sama milik class.
Bisa juga:
class Test {
static int x = 10;
static void show() {
print(Test.x);
}
}
Kemudian:
Test.show();
Output:
10
20. Static method juga bisa memanggil static method lain
Contoh:
class Calculator {
static int add(int a, int b) {
return a + b;
}
static void printResult() {
int result = add(10, 20);
print(result);
}
}
Kemudian:
Calculator.printResult();
Output:
30
Karena add() juga static.
21. Instance method berbeda
Misalnya:
class Test {
int x = 10;
void show() {
print(x);
}
}
Ini boleh.
Karena:
Test obj = Test();
obj.show();
Saat show() dipanggil, Dart tahu object mana yang dimaksud:
obj
↓
x = 10
22. Instance method boleh mengakses static member
Ini menarik.
Instance method:
class Test {
int x = 10;
static int y = 20;
void show() {
print(x);
print(y);
}
}
Ini valid.
Kenapa?
Karena instance method mempunyai object sehingga bisa mengakses:
x → instance field
dan juga class:
y → static field
Jadi instance method lebih fleksibel dalam hal akses member.
23. Gambaran aturan akses
Paling gampang:
Instance field Static field
Instance method ✅ ✅
Static method ❌ ✅
Misalnya:
class Test {
int x = 10;
static int y = 20;
void instanceMethod() {
print(x); // ✅
print(y); // ✅
}
static void staticMethod() {
print(x); // ❌
print(y); // ✅
}
}
Ini adalah salah satu tabel yang sangat bagus untuk kamu hafalkan.
24. Kenapa static method tidak punya this?
Ini adalah alasan teknis di balik aturan tadi.
Dalam instance method:
class Person {
String name = "Budi";
void show() {
print(this.name);
}
}
this berarti:
object yang sedang menjalankan method ini.
Misalnya:
Person p1 = Person();
p1.show();
Maka:
this → p1
25. Bagaimana dengan static method?
Misalnya:
class Person {
static void show() {
print(this); // ❌
}
}
Tidak ada this.
Kenapa?
Karena kita memanggil:
Person.show();
bukan:
p1.show();
Tidak ada object tertentu yang menjadi receiver.
Jadi tidak ada:
this → object tertentu
26. Analogi this
Bayangkan:
obj1.show()
Artinya:
“Hai show(), kerjakan pekerjaanmu untuk object
obj1.”
Maka method tahu:
this = obj1
Sedangkan:
Person.show()
artinya:
“Hai class Person, jalankan static method show().”
Tidak ada object tertentu.
Maka:
this = tidak tersedia
27. Contoh error this
❌:
class Test {
int x = 10;
static void show() {
print(this.x);
}
}
Akan error.
Sedangkan:
class Test {
int x = 10;
void show() {
print(this.x);
}
}
valid.
28. Static hanya boleh menjadi member class
Transcript juga membahas:
static tidak boleh digunakan pada global function.
Benar.
Misalnya kita punya function di luar class:
void show() {
print("Hello");
}
Kamu tidak bisa:
static void show() {
print("Hello");
}
di top-level.
static digunakan untuk member yang menjadi bagian dari class, seperti:
class Test {
static int x = 10;
static void show() {}
}
29. Jangan tertukar function dan method
Dalam Dart:
Function
Didefinisikan di luar class:
void sayHello() {
print("Hello");
}
Ini adalah top-level function.
Method
Didefinisikan sebagai member class:
class Person {
void sayHello() {
print("Hello");
}
}
Ini adalah method.
Jadi static dapat digunakan pada:
class Person {
static void sayHello() {}
}
tetapi bukan:
static void sayHello() {} // ❌ top-level
30. Static variable juga tidak boleh menjadi local variable
Misalnya:
void test() {
static int x = 10; // ❌
}
Tidak boleh.
static bukan keyword untuk membuat variable lokal.
Yang boleh:
class Test {
static int x = 10;
}
Karena x merupakan member class.
31. Jadi ada tiga lokasi variable yang perlu dibedakan
1. Instance field
class Test {
int x = 10;
}
Milik object.
2. Static field
class Test {
static int y = 20;
}
Milik class.
3. Local variable
void test() {
int z = 30;
}
Milik scope/function tersebut.
static tidak digunakan untuk variable lokal.
32. Contoh lengkap
class Test {
int x = 10;
static int y = 20;
void instanceMethod() {
print(x);
print(y);
}
static void staticMethod() {
print(y);
}
}
void main() {
Test obj = Test();
print(obj.x);
print(Test.y);
obj.instanceMethod();
Test.staticMethod();
}
Perhatikan cara akses:
obj.x
karena x instance.
Test.y
karena y static.
obj.instanceMethod()
karena instance method.
Test.staticMethod()
karena static method.
33. Contoh yang lebih realistis: menghitung jumlah object
Static variable sering digunakan untuk menyimpan informasi yang berlaku untuk seluruh class.
Misalnya:
class User {
static int totalUser = 0;
User() {
totalUser++;
}
}
Kemudian:
void main() {
User();
User();
User();
print(User.totalUser);
}
Output:
3
Kenapa?
Karena totalUser hanya satu.
Setiap constructor dipanggil:
User()
↓
totalUser++
Jadi:
User #1 → totalUser = 1
User #2 → totalUser = 2
User #3 → totalUser = 3
Bukan:
User #1 → punya totalUser sendiri
User #2 → punya totalUser sendiri
User #3 → punya totalUser sendiri
34. Static method + static variable
Keduanya bisa digabung:
class Counter {
static int count = 0;
static void increment() {
count++;
}
}
Kemudian:
void main() {
Counter.increment();
Counter.increment();
Counter.increment();
print(Counter.count);
}
Output:
3
Tidak ada object yang dibuat.
Kita hanya menggunakan:
Counter
↓
count
increment()
35. Contoh utility yang sangat cocok
Misalnya format rupiah sederhana:
class CurrencyUtils {
static String formatRupiah(int value) {
return "Rp$value";
}
}
Kemudian:
void main() {
print(CurrencyUtils.formatRupiah(50000));
}
Output:
Rp50000
Tidak perlu:
CurrencyUtils utils = CurrencyUtils();
karena formatRupiah() tidak membutuhkan data milik object.
36. Static bukan berarti global
Ini juga penting.
Ada perbedaan:
class Utils {
static void hello() {}
}
dengan:
void hello() {}
Yang pertama adalah static method milik class:
Utils.hello()
Yang kedua adalah top-level function:
hello()
Jadi:
static bukan sinonim dari global.
Static tetap berada di dalam class.
37. Apakah static member bisa diakses dari instance?
Tidak.
Misalnya:
class Test {
static int x = 10;
}
void main() {
Test obj = Test();
print(obj.x); // ❌
}
Gunakan:
print(Test.x);
Hal yang sama untuk static method:
class Test {
static void show() {
print("Hello");
}
}
❌:
Test obj = Test();
obj.show();
✅:
Test.show();
38. Kenapa Dart melarang akses static melalui instance?
Karena akan membingungkan konsep kepemilikan.
Misalnya:
obj.show();
biasanya kita berpikir:
show()bekerja terhadap objectobj.
Tetapi kalau show() adalah static, sebenarnya method tersebut tidak bekerja terhadap object tertentu.
Jadi Dart memaksa kita menulis:
Test.show();
Ini membuat kode lebih jelas.
39. Hubungan dengan Flutter
Di Flutter, kamu akan sering menemukan static member.
Misalnya konsep seperti:
Colors.red
atau:
Icons.add
Colors dan Icons menyediakan banyak nilai yang dapat digunakan melalui class-level API.
Kamu tidak perlu membuat:
Colors colors = Colors();
untuk mengambil Colors.red.
40. Contoh lain yang akan sering kamu temui
Dalam Flutter/Dart, API sering menggunakan class-level member untuk nilai atau utility.
Misalnya:
DateTime.now()
Ini adalah static method.
Kita tidak membuat object DateTime terlebih dahulu hanya untuk meminta waktu saat ini.
Konsepnya:
DateTime
↓
now()
↓
waktu sekarang
Ini contoh yang sangat bagus untuk memahami mengapa static method berguna.
41. Kapan menggunakan static variable?
Gunakan ketika data:
bersifat milik class dan dibagikan oleh seluruh instance.
Contoh:
jumlah object
konfigurasi global class
counter
cache tertentu
constant/class-level data
registry
Contoh:
class User {
static int totalUsers = 0;
}
42. Kapan menggunakan static method?
Gunakan ketika method:
tidak membutuhkan state/data dari instance tertentu.
Contoh:
class MathUtils {
static int square(int x) {
return x * x;
}
}
Method tersebut tidak membutuhkan:
this.x
this.name
this.age
sehingga cocok menjadi static.
43. Kapan JANGAN menggunakan static?
Misalnya kita punya:
class Person {
String name;
void sayHello() {
print("Hello, my name is $name");
}
}
Ini tidak cocok menjadi static.
Kenapa?
Karena sayHello() membutuhkan name milik object.
Misalnya:
p1 → name = Budi
p2 → name = Andi
Ketika:
p1.sayHello();
harus menghasilkan:
Hello, my name is Budi
Sedangkan:
p2.sayHello();
harus:
Hello, my name is Andi
Maka method harus menjadi instance method.
44. Perbandingan yang sangat penting
Instance
class Person {
String name;
Person(this.name);
void sayHello() {
print("Hello $name");
}
}
Pemakaian:
Person p1 = Person("Budi");
Person p2 = Person("Andi");
p1.sayHello();
p2.sayHello();
Output:
Hello Budi
Hello Andi
Karena method bekerja berdasarkan object.
Static
class MathUtils {
static int add(int a, int b) {
return a + b;
}
}
Pemakaian:
MathUtils.add(10, 20);
Tidak ada object yang dibutuhkan.
45. Visualisasi memory yang sederhana
Misalnya:
class Person {
String name;
static int total = 0;
Person(this.name);
}
Kemudian:
Person p1 = Person("Budi");
Person p2 = Person("Andi");
Secara konsep:
Person class
┌─────────────┐
│ static total│
│ = 0 │
└─────────────┘
│
┌─────────┴─────────┐
↓ ↓
Person Object #1 Person Object #2
name = "Budi" name = "Andi"
Jadi:
name
↓
masing-masing object
total
↓
satu untuk class
46. Aturan lengkap static variable
Untuk kamu hafalkan:
✅ Static field harus menjadi member class
class Test {
static int x = 10;
}
❌ Bukan local variable
void test() {
static int x = 10; // ❌
}
❌ Bukan top-level variable
static int x = 10; // ❌
✅ Akses dengan class
Test.x;
❌ Jangan melalui instance
Test obj = Test();
obj.x; // ❌
47. Aturan lengkap static method
Bisa:
class Test {
static void show() {}
}
Panggil:
Test.show();
Tidak bisa mengakses instance field langsung:
class Test {
int x = 10;
static void show() {
print(x); // ❌
}
}
Bisa mengakses static field:
class Test {
static int x = 10;
static void show() {
print(x); // ✅
}
}
Tidak memiliki this
static void show() {
print(this); // ❌
}
48. Diagram akses
Simpan diagram ini:
CLASS
│
┌─────────┴─────────┐
│ │
static instance
│ │
│ └── Object #1
│ └── Object #2
│ └── Object #3
│
├── static field
└── static method
Sedangkan instance member:
Object #1
├── field
└── method
Object #2
├── field
└── method
Object #3
├── field
└── method
49. Cara cepat membedakan
Kalau kamu melihat:
obj.name
kemungkinan:
name → instance member
Kalau:
Person.name
kemungkinan:
name → static member
Begitu juga:
obj.show()
→ instance method.
Person.show()
→ static method.
50. Kesalahan paling umum pemula
Kesalahan 1
Mengira static = constant.
❌ Salah.
static int count = 0;
masih bisa berubah.
count++;
boleh.
Kesalahan 2
Mengakses static melalui object.
❌:
obj.count
✅:
ClassName.count
Kesalahan 3
Static method mengakses field biasa.
❌:
class Test {
int x = 10;
static void show() {
print(x);
}
}
Kesalahan 4
Menggunakan this dalam static method.
❌:
static void show() {
print(this);
}
Static method tidak mempunyai this.
Kesalahan 5
Menggunakan static pada function biasa.
❌:
static void hello() {}
di luar class.
Kalau ingin top-level function:
void hello() {}
51. Static vs final vs const
Karena sebelumnya kita membahas const, ini juga penting.
Ketiganya berbeda.
static
Menentukan kepemilikan:
static int count = 0;
Artinya member milik class.
final
Menentukan assignment:
final int age = 20;
Artinya variable/reference tidak bisa di-assign ulang.
const
Menentukan constant value/object:
const int max = 100;
52. Bisa digabung
Contoh:
class AppConfig {
static const String appName = "My App";
}
Ini berarti:
static
↓
milik class
const
↓
nilainya constant
Akses:
print(AppConfig.appName);
Ini pola yang sangat umum.
53. Contoh Flutter yang realistis
Misalnya kamu membuat class konfigurasi:
class AppConfig {
static const String appName = "Belajar Flutter";
static const String version = "1.0.0";
}
Kemudian:
Text(AppConfig.appName)
dan:
Text(AppConfig.version)
Tidak perlu membuat:
AppConfig config = AppConfig();
karena data tersebut memang class-level constant.
54. Kesimpulan besar
Kalau disederhanakan:
INSTANCE MEMBER
↓
milik object
↓
harus punya object
↓
obj.field
obj.method()
Sedangkan:
STATIC MEMBER
↓
milik class
↓
tidak membutuhkan object
↓
Class.field
Class.method()
Dan aturan akses:
Instance Static
Instance method ✅ ✅
Static method ❌ ✅
55. Cheat sheet terakhir
class Test {
int x = 10; // instance field
static int y = 20; // static field
void normalMethod() { // instance method
print(x); // ✅
print(y); // ✅
}
static void staticMethod() { // static method
print(y); // ✅
print(x); // ❌
// print(this); // ❌
}
}
Pemakaiannya:
void main() {
Test obj = Test();
print(obj.x); // ✅ instance field
print(Test.y); // ✅ static field
obj.normalMethod(); // ✅ instance method
Test.staticMethod(); // ✅ static method
}
Kalimat paling penting:
Instance member berhubungan dengan object, sedangkan static member berhubungan dengan class.
Kalau kamu menemukan:
static int count = 0;
bacanya:
“
countadalah data milik class, bukan data milik masing-masing object.”
Kalau menemukan:
static void calculate() {}
bacanya:
“
calculate()adalah method milik class yang bisa dipanggil tanpa membuat object.”
Dan kalau menemukan error karena static method mencoba mengakses field biasa, ingat pertanyaan sederhana ini:
“Object yang mana?”
Kalau tidak ada object yang sedang menjadi target, maka static method memang tidak punya akses langsung ke instance member tersebut.