Transkrip ini membahas getter dan setter di Dart. Materinya cukup panjang, tetapi sebenarnya inti konsepnya bisa dibuat sangat sederhana:

Getter = cara membaca/mengambil nilai property. Setter = cara mengubah/memberikan nilai property.

Namun yang membuat getter/setter menarik adalah kita bisa menyisipkan validasi, perhitungan, atau aturan tertentu ketika property dibaca atau diubah.

Saya akan jelaskan dari dasar sampai bagian yang lebih lanjut, sekaligus meluruskan beberapa bagian transkrip yang kurang tepat.

1. Apa itu getter dan setter?

Misalkan kita punya class:

class Person {
  String name;
  int age;

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

Kemudian:

void main() {
  Person p = Person("Budi", 20);

  print(p.age);
  p.age = 25;
}

Di sini kita bisa:

print(p.age);

untuk membaca age.

Dan:

p.age = 25;

untuk mengubah age.

Dart sebenarnya sudah menyediakan mekanisme implicit getter dan implicit setter untuk field instance yang bisa diakses dari luar.

Secara sederhana:

p.age
  ↓
implicit getter
  ↓
membaca age

Sedangkan:

p.age = 25
  ↓
implicit setter
  ↓
mengubah age

2. Implicit getter dan setter

Misalnya:

class Person {
  String name = "Budi";
  int age = 20;
}

Karena name dan age bisa diakses dari luar class, kita bisa:

Person p = Person();

print(p.name);
print(p.age);

p.name = "Andi";
p.age = 25;

Dart menyediakan akses read/write tersebut secara otomatis.

Jadi kita tidak perlu menulis:

String getName() {
  return name;
}

void setName(String value) {
  name = value;
}

untuk sekadar membaca dan mengubah field public.

3. Lalu mengapa kita membutuhkan explicit getter/setter?

Ini pertanyaan terpenting dari materi ini.

Kalau kita sudah bisa:

p.age

dan:

p.age = 25;

kenapa harus membuat:

get age

dan:

set age(...)

?

Jawabannya:

Karena explicit getter/setter memungkinkan kita menambahkan logic ketika property dibaca atau diubah.

Misalnya kita ingin:

umur tidak boleh negatif.

Kalau field public biasa:

class Person {
  int age = 20;
}

kita bisa melakukan:

p.age = -100;

Dart tidak tahu bahwa kita menganggap -100 tidak valid.

Tetapi dengan setter:

set age(int value) {
  if (value >= 0) {
    _age = value;
  }
}

kita bisa mengontrolnya.

4. Getter = membaca nilai

Syntax getter:

ReturnType get namaGetter {
  return nilai;
}

Contoh:

class Person {
  int _age = 20;

  int get age {
    return _age;
  }
}

Di sini:

int

adalah return type.

get

adalah keyword getter.

age

adalah nama getter.

Dan:

return _age;

mengembalikan nilai.

5. Getter tidak mempunyai parameter

Perhatikan:

int get age {
  return _age;
}

Tidak ada:

()

Getter tidak menerima parameter.

Jadi ini salah:

int get age() { // ❌
  return _age;
}

Getter bukan method biasa.

Bentuknya:

int get age

bukan:

int get age()

6. Cara memanggil getter

Misalnya:

class Person {
  int _age = 20;

  int get age {
    return _age;
  }
}

Kita membuat object:

final p = Person();

Kemudian:

print(p.age);

Bukan:

print(p.age());

Ini penting.

Getter terlihat seperti property:

p.age

bukan seperti method:

p.getAge()

7. Getter bisa menggunakan arrow syntax

Kalau logic-nya hanya satu expression:

int get age {
  return _age;
}

bisa ditulis:

int get age => _age;

Keduanya sama.

Bentuk panjang

int get age {
  return _age;
}

Bentuk singkat

int get age => _age;

Tetapi tidak wajib menggunakan arrow syntax.

Kalau logic-nya kompleks, gunakan body biasa.

Contoh:

int get age {
  if (_age < 0) {
    return 0;
  }

  return _age;
}

8. Setter = mengubah nilai

Sekarang kita masuk ke setter.

Syntax:

set namaSetter(T value) {
  // logic
}

Contoh:

class Person {
  int _age = 20;

  set age(int value) {
    _age = value;
  }
}

Perhatikan:

set age(int value)

Setter mempunyai tepat satu parameter.

9. Setter harus mempunyai satu parameter

Ini valid:

set age(int value) {
  _age = value;
}

Ini tidak valid:

set age() { // ❌
}

Karena tidak ada parameter.

Ini juga tidak valid:

set age(int value, int value2) { // ❌
}

Karena ada dua parameter.

Jadi:

Getter
→ 0 parameter

Setter
→ tepat 1 parameter

10. Setter tidak mengembalikan nilai

Setter digunakan untuk melakukan assignment.

Contoh:

set age(int value) {
  _age = value;
}

Kita tidak membuat:

int set age(int value) { // ❌
}

Dan secara praktik, Dart juga tidak mengharapkan setter memiliki return value.

Biasanya kita cukup menulis:

set age(int value) {
  _age = value;
}

Bukan:

void set age(int value) { // ❌
}

Jadi pola sederhananya:

int get age => _age;

set age(int value) {
  _age = value;
}

11. Getter dan setter bisa memiliki nama yang sama

Ini menarik.

Kita bisa memiliki:

class Person {
  int _age = 20;

  int get age => _age;

  set age(int value) {
    _age = value;
  }
}

Getter:

get age

Setter:

set age(...)

Nama keduanya sama-sama:

age

Ini valid.

12. Bagaimana Dart tahu harus menggunakan getter atau setter?

Dart melihat cara kita menggunakan property tersebut.

Kalau kita membaca:

print(p.age);

Dart menggunakan getter.

p.age
 ↓
GETTER
 ↓
ambil nilai

Tetapi kalau kita melakukan:

p.age = 25;

Dart menggunakan setter.

p.age = 25
    ↓
 SETTER
    ↓
ubah nilai

Jadi meskipun namanya sama:

age

Dart tahu dari konteks penggunaannya.

13. Contoh lengkap getter + setter

class Person {
  int _age = 20;

  int get age => _age;

  set age(int value) {
    _age = value;
  }
}

void main() {
  final p = Person();

  print(p.age);

  p.age = 25;

  print(p.age);
}

Output:

20
25

Urutannya:

print(p.age)
     ↓
 getter
     ↓
 _age
     ↓
 20

Kemudian:

p.age = 25
     ↓
 setter
     ↓
_age = 25

Kemudian:

print(p.age)
     ↓
 getter
     ↓
 _age
     ↓
 25

14. Kenapa biasanya field dibuat private?

Kita sering melihat:

int _age;

bukan:

int age;

Kemudian:

int get age => _age;

set age(int value) {
  // validasi
  _age = value;
}

Tujuannya adalah memberikan kontrol terhadap akses.

Kita tidak ingin orang luar bisa langsung melakukan:

p._age = -100;

Di Dart, _age bersifat private terhadap library.

Kemudian akses dari luar diberikan melalui:

p.age

dan:

p.age = 25;

15. Use case #1 — Validasi input

Ini salah satu kegunaan getter/setter yang paling penting.

Misalnya:

class Student {
  String name;
  int _age;

  Student(this.name, this._age);

  int get age => _age;

  set age(int value) {
    if (value > 0) {
      _age = value;
    } else {
      print("Age tidak boleh negatif atau nol");
    }
  }
}

Kemudian:

void main() {
  final student = Student("Budi", 21);

  student.age = -5;

  print(student.age);

  student.age = 25;

  print(student.age);
}

Output kira-kira:

Age tidak boleh negatif atau nol
21
25

Kenapa ketika:

student.age = -5;

nilainya tetap 21?

Karena setter melakukan:

if (value > 0) {
  _age = value;
}

-5 tidak memenuhi syarat.

Maka assignment tidak dilakukan.

16. Bandingkan tanpa setter

Kalau kita hanya menggunakan:

class Student {
  int age = 21;
}

orang bisa melakukan:

student.age = -5;

Tidak ada validasi.

Jadi:

Public field biasa
      ↓
bebas diubah

Private field + setter
      ↓
perubahan melewati aturan kita

Ini salah satu alasan utama explicit setter digunakan.

17. Use case #2 — Getter untuk melakukan perhitungan

Getter tidak harus mengembalikan field secara langsung.

Misalnya:

class Rectangle {
  double length;
  double width;

  Rectangle(this.length, this.width);

  double get area {
    return length * width;
  }
}

Kemudian:

final rectangle = Rectangle(10, 5);

print(rectangle.area);

Hasil:

50

Perhatikan bahwa kita tidak memiliki field:

double area;

area adalah computed property.

Nilainya dihitung ketika getter dipanggil.

18. Kenapa ini enak menggunakan getter?

Tanpa getter, kita mungkin menulis:

rectangle.calculateArea()

Tetapi getter memungkinkan:

rectangle.area

Secara semantik terasa seperti:

“Berapa area rectangle ini?”

Bukan:

“Jalankan sebuah proses bernama calculateArea.”

Keduanya bisa saja digunakan, tetapi getter cocok untuk sesuatu yang secara konsep merupakan property hasil perhitungan.

19. Contoh area dan perimeter

class Rectangle {
  double length;
  double width;

  Rectangle(this.length, this.width);

  double get area => length * width;

  double get perimeter => 2 * (length + width);
}

Kemudian:

final rectangle = Rectangle(10, 5);

print(rectangle.area);
print(rectangle.perimeter);

Output:

50.0
30.0

Di sini kita mempunyai:

length
width
  │
  ├──→ area
  │
  └──→ perimeter

Satu field bisa digunakan oleh banyak getter.

20. Getter tidak harus memiliki tipe yang sama dengan field

Misalnya:

class Employee {
  final DateTime joiningDate;

  Employee(this.joiningDate);

  int get daysWorked {
    return DateTime.now().difference(joiningDate).inDays;
  }
}

Field:

DateTime joiningDate

Tetapi getter:

int get daysWorked

menghasilkan:

DateTime → input
int      → hasil

Jadi getter tidak harus mengembalikan tipe yang sama dengan field yang digunakan di dalamnya.

Ini adalah konsep yang penting.

21. Contoh lebih nyata

final employee = Employee(
  DateTime(2022, 6, 18),
);

print(employee.daysWorked);

daysWorked akan dihitung berdasarkan:

DateTime.now()

dikurangi:

joiningDate

Jadi getter bisa menjadi computed property.

22. Use case #3 — Membuat field read-only

Ini juga sangat penting.

Misalnya kita mempunyai:

class Person {
  final String _name;

  Person(this._name);

  String get name => _name;
}

Dari luar kita bisa:

final p = Person("Budi");

print(p.name); // ✅

Tetapi kita tidak menyediakan setter.

Jadi:

p.name = "Andi"; // ❌

tidak bisa dilakukan.

Dengan demikian:

name
 ↓
getter tersedia
 ↓
boleh dibaca

setter tidak tersedia
 ↓
tidak boleh diubah dari luar

Inilah konsep read-only property.

23. Kenapa tidak langsung membuat field public?

Misalnya:

class Person {
  String name = "Budi";
}

Karena public, orang bisa:

print(p.name);

dan:

p.name = "Andi";

Artinya:

read  → boleh
write → boleh

Kalau kita ingin:

read  → boleh
write → tidak boleh

kita bisa menggunakan:

String _name;

String get name => _name;

tanpa setter.

24. Ini berbeda dengan membuat field private saja

Kalau kita hanya punya:

class Person {
  String _name = "Budi";
}

maka dari luar library:

print(p._name);

tidak bisa.

Artinya:

read  → tidak boleh
write → tidak boleh

Tetapi dengan getter:

String get name => _name;

menjadi:

read  → boleh
write → tidak boleh

Ini sangat berguna.

25. Empat kemungkinan akses

Kita bisa membayangkan seperti ini:

Ini salah satu cara terbaik memahami tujuan getter/setter.

26. Use case #4 — Programmer convenience

Getter/setter juga membuat API class terasa lebih natural.

Bandingkan:

Dengan method biasa

student.getAge();
student.setAge(25);

Dengan getter/setter

student.age;
student.age = 25;

Getter/setter membuat property terlihat seperti data biasa, walaupun sebenarnya ada logic yang berjalan.

27. Kenapa tidak selalu menggunakan getter/setter?

Ini bagian yang sangat penting dari video.

Misalnya:

class Student {
  String name = "";

  String get studentName => name;

  set studentName(String value) {
    name = value;
  }
}

Ini sebenarnya tidak memberikan banyak manfaat.

Kita hanya melakukan:

getter:
ambil nilai → langsung return

setter:
terima nilai → langsung assign

Tidak ada:

• validasi
• transformasi
• perhitungan
• aturan bisnis
• kontrol akses tambahan

Kalau memang field tersebut public dan tidak membutuhkan logic tambahan, biasanya cukup:

class Student {
  String name = "";
}

Lebih sederhana.

28. Tetapi ada sedikit nuansa penting

Video mengatakan bahwa membuat getter/setter sederhana pada private field itu seolah-olah “menghilangkan security”.

Lebih tepatnya:

Getter/setter tersebut tidak memberikan pembatasan tambahan terhadap perubahan, karena setter masih membolehkan semua nilai masuk.

Contohnya:

class Student {
  String _name = "";

  String get name => _name;

  set name(String value) {
    _name = value;
  }
}

Dari luar:

student.name = "Budi";
student.name = "Andi";

semuanya tetap boleh.

Jadi kalau tujuanmu hanya membuat field private tetapi kemudian menyediakan getter + setter yang bebas, manfaat encapsulation-nya memang menjadi lebih kecil.

Tetapi tetap ada satu keuntungan penting:

Implementasi internal bisa diubah nanti tanpa harus mengubah cara pemakai class menggunakan property tersebut.

29. Contoh evolusi class

Awalnya:

class User {
  String name = "";
}

Pemakai:

user.name = "Budi";

Kemudian kita membutuhkan validasi.

Kita bisa mengubah internal class menjadi:

class User {
  String _name = "";

  String get name => _name;

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

Pemakai tetap menggunakan:

user.name = "Budi";

Tidak perlu mengubah menjadi:

user.setName("Budi");

Inilah salah satu manfaat desain property menggunakan getter/setter.

30. Getter vs method biasa

Keduanya bisa melakukan perhitungan.

Misalnya:

double get area => length * width;

atau:

double calculateArea() {
  return length * width;
}

Keduanya mungkin valid.

Tetapi secara desain:

rectangle.area

terasa seperti property.

Sedangkan:

rectangle.calculateArea()

terasa seperti aksi/perintah.

Secara sederhana:

Getter cocok ketika hasilnya secara konsep merupakan property dari object.

Method cocok ketika kita sedang meminta object melakukan suatu tindakan.

31. Getter bisa lebih kompleks

Misalnya:

class Person {
  String firstName;
  String lastName;

  Person(this.firstName, this.lastName);

  String get fullName {
    final result = "$firstName $lastName";
    return result.trim();
  }
}

Pemakaian:

final p = Person("Budi", "Santoso");

print(p.fullName);

Output:

Budi Santoso

Getter melakukan logic sebelum memberikan hasil.

32. Setter juga bisa melakukan transformasi

Misalnya:

class User {
  String _name = "";

  String get name => _name;

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

Kemudian:

final user = User();

user.name = "   Budi   ";

print(user.name);

Output:

Budi

Jadi setter tidak sekadar:

_name = value;

tetapi bisa melakukan:

input
 ↓
validasi / transformasi
 ↓
simpan

33. Setter dengan validasi yang lebih realistis

Contohnya umur:

class Student {
  int _age;

  Student(this._age);

  int get age => _age;

  set age(int value) {
    if (value < 0) {
      throw ArgumentError("Age tidak boleh negatif");
    }

    _age = value;
  }
}

Sekarang:

student.age = 20;

valid.

Tetapi:

student.age = -5;

akan ditolak.

Alurnya:

student.age = -5
       ↓
setter
       ↓
value < 0 ?
       ↓
     YES
       ↓
tolak

34. Getter dan setter tidak harus selalu berpasangan

Ini juga penting.

Kita bisa hanya mempunyai getter:

String get name => _name;

Tanpa setter.

Ini berguna untuk read-only property.

Kita juga bisa memiliki setter tanpa getter:

set password(String value) {
  _password = value;
}

Walaupun dalam desain nyata, setter-only property lebih jarang dan harus punya alasan yang jelas.

35. Getter dan setter bisa digunakan untuk static variable

Ini menghubungkan materi sebelumnya tentang static.

Misalnya:

class Counter {
  static int _count = 0;

  int get count => _count;

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

Kemudian:

final c1 = Counter();
final c2 = Counter();

c1.count = 10;

print(c2.count);

Output:

10

Kenapa?

Karena:

_count

adalah static.

Jadi hanya ada satu nilai untuk seluruh class.

Getter/setter di atas hanyalah instance member yang menjadi perantara.

36. Tentang return type getter

Transkrip mengatakan bahwa kalau return type getter tidak ditulis, default-nya dynamic.

Ada sedikit nuansa penting di sini.

Misalnya:

class Person {
  String _name = "Budi";

  get name => _name;
}

Karena kita tidak menulis tipe secara eksplisit, tipe getter dapat diinfer dari expression yang dikembalikan.

Lebih baik untuk kode yang jelas dan maintainable kita tulis:

String get name => _name;

Daripada mengandalkan bentuk tanpa tipe jika API tersebut penting.

Jadi untuk pemula, biasakan:

String get name => _name;
int get age => _age;
double get salary => _salary;

37. Getter bisa mengembalikan tipe yang berbeda

Contohnya:

class Employee {
  DateTime joiningDate;

  Employee(this.joiningDate);

  int get daysWorked {
    return DateTime.now()
        .difference(joiningDate)
        .inDays;
  }
}

Field:

DateTime joiningDate

Getter:

int get daysWorked

Tidak ada masalah.

Karena getter tidak harus merepresentasikan satu field tertentu. Getter bisa menghasilkan computed value.

38. “Satu field bisa punya banyak getter”

Lebih tepatnya, satu field bisa digunakan oleh banyak getter.

Misalnya:

class Rectangle {
  double length;
  double width;

  Rectangle(this.length, this.width);

  double get area => length * width;

  double get perimeter => 2 * (length + width);
}

Di sini:

length ──┐
         ├──→ area
width  ──┘

length ──┐
         ├──→ perimeter
width  ──┘

area dan perimeter bukan getter untuk field length secara langsung.

Keduanya adalah computed properties yang menggunakan length dan width.

Jadi jangan terlalu terpaku pada kalimat:

“Satu field mempunyai banyak getter.”

Lebih tepat:

Satu atau beberapa field dapat digunakan oleh banyak getter yang menghasilkan nilai berbeda.

39. Apakah getter/setter lebih lambat daripada method?

Secara umum, jangan memilih getter/setter atau method berdasarkan asumsi bahwa salah satunya pasti lebih cepat.

Getter/setter adalah bagian dari bahasa Dart dan compiler/runtime dapat mengoptimalkan kode tersebut.

Yang lebih penting adalah desain API dan keterbacaan kode.

Misalnya:

rectangle.area

lebih natural sebagai property daripada:

rectangle.getArea()

jika area memang dipandang sebagai property hasil perhitungan.

Jadi jangan berpikir:

getter = lambat
method = cepat

Tidak sesederhana itu.

40. Getter/setter vs method

41. Contoh desain yang bagus

Misalnya class rekening bank:

class BankAccount {
  double _balance;

  BankAccount(this._balance);

  double get balance => _balance;

  void deposit(double amount) {
    if (amount <= 0) {
      throw ArgumentError("Jumlah deposit harus positif");
    }

    _balance += amount;
  }

  void withdraw(double amount) {
    if (amount <= 0) {
      throw ArgumentError("Jumlah penarikan harus positif");
    }

    if (amount > _balance) {
      throw ArgumentError("Saldo tidak cukup");
    }

    _balance -= amount;
  }
}

Di sini:

account.balance

adalah getter.

Kita tidak menyediakan setter:

account.balance = 1_000_000; // ❌

Karena saldo tidak boleh diubah sembarangan.

Perubahan saldo harus melalui:

account.deposit(100000);

atau:

account.withdraw(50000);

Ini contoh encapsulation yang jauh lebih bermakna.

42. Kenapa tidak membuat setter untuk balance?

Kalau kita membuat:

set balance(double value) {
  _balance = value;
}

maka orang bisa:

account.balance = -1000000;

atau:

account.balance = 999999999;

tanpa mengikuti aturan transaksi.

Lebih baik:

balance
   ↓
getter saja
   ↓
read-only

Sedangkan perubahan dilakukan melalui method yang mempunyai aturan:

deposit()
withdraw()

Ini contoh bagaimana getter/setter dan method bisa digunakan bersama.

43. Hubungan dengan encapsulation

Konsep besarnya adalah:

Encapsulation
     ↓
sembunyikan detail internal
     ↓
berikan akses yang terkontrol

Misalnya:

class Student {
  int _age = 20;

  int get age => _age;

  set age(int value) {
    if (value > 0) {
      _age = value;
    }
  }
}

Dari luar kita tidak perlu tahu bagaimana _age disimpan.

Kita cukup menggunakan:

student.age

dan:

student.age = 25;

Class yang mengatur bagaimana data tersebut diproses.

44. Pola mental yang sangat mudah

Bayangkan getter dan setter seperti pintu.

Field:

_age

ada di dalam rumah.

Getter:

GET

adalah pintu untuk melihat/mengambil sesuatu dari dalam.

Setter:

SET

adalah pintu untuk memasukkan/mengubah sesuatu.

Dan setter bisa mempunyai satpam:

Anda ingin memasukkan -5?
        ↓
   SETTER
        ↓
 "Tidak boleh!"

Sedangkan getter:

Anda ingin melihat age?
        ↓
    GETTER
        ↓
      25

45. Pola yang perlu kamu hafalkan

Getter

Type get propertyName => value;

Contoh:

int get age => _age;

Penggunaan:

print(student.age);

Setter

set propertyName(Type value) {
  // logic
}

Contoh:

set age(int value) {
  if (value > 0) {
    _age = value;
  }
}

Penggunaan:

student.age = 25;

46. Getter + setter lengkap

Pola yang sering kamu temui:

class Person {
  String _name;
  int _age;

  Person(this._name, this._age);

  String get name => _name;

  set name(String value) {
    _name = value;
  }

  int get age => _age;

  set age(int value) {
    if (value >= 0) {
      _age = value;
    }
  }
}

Penggunaan:

void main() {
  final person = Person("Budi", 20);

  print(person.name);
  print(person.age);

  person.name = "Andi";
  person.age = 25;

  print(person.name);
  print(person.age);
}

Output:

Budi
20
Andi
25

47. Jangan gunakan getter/setter hanya demi “gaya OOP”

Ini salah satu pesan penting dari video.

Tidak perlu mengubah:

String name = "Budi";

menjadi:

String _name = "Budi";

String get name => _name;

set name(String value) {
  _name = value;
}

kalau memang tidak ada kebutuhan.

Gunakan getter/setter ketika ada alasan seperti:

1. Validasi

set age(int value) {
  if (value >= 0) {
    _age = value;
  }
}

2. Perhitungan

double get area => length * width;

3. Read-only property

String get name => _name;

tanpa setter.

4. Transformasi

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

5. API yang lebih nyaman

user.name

daripada:

user.getName()

jika secara konsep name adalah property.

48. Beberapa koreksi penting dari transkrip

Ada beberapa bagian transkrip yang perlu kamu pahami dengan versi yang lebih tepat.

❌ “Getter dan setter adalah method biasa”

Lebih tepat:

Getter dan setter adalah special members/accessors yang digunakan seperti property.

❌ Getter harus selalu satu baris

Tidak.

Bisa:

int get age => _age;

atau:

int get age {
  if (_age < 0) {
    return 0;
  }

  return _age;
}

❌ Getter tidak mempunyai return type kalau tidak ditulis berarti selalu dynamic

Lebih aman untuk memahami bahwa tipe yang tidak ditulis dapat diinfer/berperilaku berdasarkan deklarasi dan expression-nya. Untuk API yang jelas, tuliskan tipe secara eksplisit:

String get name => _name;

❌ Setter mempunyai return type void

Dalam syntax Dart, setter tidak ditulis dengan return type seperti method biasa.

Gunakan:

set age(int value) {
  _age = value;
}

❌ Setter boleh memiliki beberapa parameter

Tidak.

Setter harus mempunyai tepat satu parameter.

set age(int value) {} // ✅

❌ Getter boleh menerima parameter kosong

Tidak.

Ini salah:

int get age() {} // ❌

Getter dipanggil:

person.age

bukan:

person.age()

49. Hubungkan dengan materi this

Materi ini juga nyambung dengan pembahasan this sebelumnya.

Misalnya:

class Person {
  String _name;

  Person(this._name);

  String get name => this._name;

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

Di sini:

this._name

berarti:

_name milik object saat ini.

Tetapi this sebenarnya bisa dihilangkan:

String get name => _name;

set name(String value) {
  _name = value;
}

Karena Dart sudah tahu bahwa _name adalah instance field dari current object.

50. Hubungan dengan Flutter

Getter dan setter akan sangat berguna ketika kamu membuat model atau class yang memiliki aturan tertentu.

Misalnya:

class Product {
  final String name;
  double _price;

  Product(this.name, this._price);

  double get price => _price;

  set price(double value) {
    if (value >= 0) {
      _price = value;
    }
  }

  double get priceWithTax {
    return _price * 1.11;
  }
}

Sekarang:

final product = Product("Laptop", 10000000);

Bisa:

print(product.price);

Bisa juga:

product.price = 9000000;

Dan:

print(product.priceWithTax);

priceWithTax adalah computed getter.

Konsep seperti ini sangat berguna ketika kamu membuat model/data class dalam aplikasi Flutter.

51. Kesimpulan paling penting

Kalau seluruh video diringkas menjadi beberapa kalimat:

Getter digunakan untuk membaca property.

int get age => _age;

Dipakai:

print(person.age);

Setter digunakan untuk mengubah property.

set age(int value) {
  _age = value;
}

Dipakai:

person.age = 25;

Getter tidak menerima parameter.

0 parameter

Setter harus menerima tepat satu parameter.

1 parameter

Getter dan setter bisa memiliki nama yang sama.

int get age => _age;

set age(int value) {
  _age = value;
}

Dart membedakan berdasarkan cara penggunaannya:

person.age       // getter
person.age = 25  // setter

Getter sangat cocok untuk computed property.

double get area => length * width;

Setter sangat cocok untuk validasi.

set age(int value) {
  if (value >= 0) {
    _age = value;
  }
}

Getter tanpa setter bisa membuat property read-only dari luar.

String get name => _name;

Jangan membuat getter/setter hanya untuk membungkus field public tanpa alasan.

Kalau tidak ada validasi, perhitungan, kontrol akses, transformasi, atau kebutuhan desain API, field public sederhana sering kali sudah cukup.

🧠 Rumus hafalan

GETTER
   ↓
READ
   ↓
property

SETTER
   ↓
WRITE / CHANGE
   ↓
property

Atau paling gampang:

Getter = “Kasih saya nilainya.” Setter = “Saya mau kasih kamu nilai baru.”

Dan alasan utama kita membuat explicit getter/setter adalah supaya di antara permintaan membaca/mengubah data tersebut, kita bisa menyisipkan aturan atau logic.