Materi ini membahas abstract method dan abstract class di Dart, dan ini penting sekali untuk memahami OOP serta bagaimana Flutter menggunakan konsep inheritance, interface, dan polymorphism.

Ada beberapa bagian dari transcript yang istilahnya agak keliru karena hasil speech-to-text, jadi saya akan luruskan sekaligus jelaskan konsep Dart yang benar.

1. Gambaran besar: apa itu abstract?

Sebelum masuk kode, bayangkan kita membuat aplikasi perbankan.

Kita punya beberapa jenis rekening:

• SavingAccount
• CurrentAccount
• InvestmentAccount

Semuanya punya operasi:

• deposit()
• withdraw()

Tetapi cara melakukan withdraw() bisa berbeda-beda.

Misalnya:

SavingAccount
    withdraw()
    → aturan rekening tabungan

CurrentAccount
    withdraw()
    → aturan rekening berjalan

InvestmentAccount
    withdraw()
    → aturan rekening investasi

Kita ingin membuat aturan:

“Setiap jenis Account WAJIB memiliki deposit() dan withdraw().”

Nah, abstract method sangat cocok untuk membuat aturan tersebut.

2. Apa itu Abstract Method?

Abstract method adalah method yang hanya memiliki deklarasi/signature, tetapi tidak memiliki body/implementasi.

Contoh:

abstract class Account {
  void deposit();

  void withdraw();
}

Perhatikan:

void deposit();

Tidak ada:

{
   // isi method
}

Jadi kita hanya mengatakan:

“Method deposit() harus ada.”

Tetapi kita belum menentukan:

“Bagaimana cara deposit() bekerja?”

Itu akan ditentukan oleh subclass.

3. Kenapa abstract method harus berada di abstract class?

Misalnya kita menulis:

class Account {
  void deposit();
}

Ini tidak valid.

Karena Account adalah class biasa.

Kalau kita ingin memiliki abstract method, class tersebut harus menjadi:

abstract class Account {
  void deposit();
}

Jadi:

abstract method
       ↓
harus berada dalam
       ↓
abstract class

4. Apa itu Abstract Class?

Abstract class adalah class yang diberi keyword:

abstract

Contoh:

abstract class Animal {
  void sound();
}

Di sini:

abstract class Animal

berarti Animal adalah abstract class.

5. Apakah abstract class harus memiliki abstract method?

Tidak.

Ini salah satu poin penting.

Abstract class boleh memiliki:

Hanya abstract method

abstract class Animal {
  void sound();
  void move();
}

Hanya concrete method

abstract class Animal {
  void eat() {
    print("Animal is eating");
  }
}

Campuran

abstract class Animal {
  void sound();

  void eat() {
    print("Animal is eating");
  }
}

Jadi:

Abstract class
├── abstract method
├── concrete method
└── atau kombinasi keduanya

6. Apa itu Concrete Method?

Concrete method adalah method yang memiliki body/implementasi.

Contoh:

void eat() {
  print("Animal is eating");
}

Berbeda dengan:

void sound();

Yang tidak memiliki body.

Jadi:

7. Abstract Class Tidak Bisa Dibuat Object-nya

Ini aturan penting.

Misalnya:

abstract class Animal {
  void sound();
}

Kita tidak boleh:

void main() {
  Animal animal = Animal(); // ERROR
}

Karena:

Abstract class tidak dapat di-instansiasi secara langsung.

Kenapa?

Karena abstract class sering berisi method yang belum memiliki implementasi.

Contohnya:

abstract class Animal {
  void sound();
}

Pertanyaannya:

Kalau kita membuat Animal() lalu memanggil sound(), harus menjalankan kode yang mana?

Tidak ada implementasinya.

Karena itu Dart tidak mengizinkan kita membuat object langsung dari abstract class.

8. Tapi Abstract Class Bisa Menjadi Parent

Walaupun tidak bisa dibuat object secara langsung, abstract class bisa diwariskan.

Contoh:

abstract class Animal {
  void sound();
}

Kemudian:

class Cat extends Animal {
  @override
  void sound() {
    print("Meow");
  }
}

Sekarang kita bisa:

void main() {
  Cat cat = Cat();

  cat.sound();
}

Output:

Meow

Kenapa boleh?

Karena Cat sudah memberikan implementasi konkret terhadap:

void sound();

9. Abstract Method = Kontrak

Ini cara paling mudah untuk memahami abstract method.

Anggap abstract class sebagai kontrak.

Misalnya:

abstract class Account {
  void deposit();
  void withdraw();
}

Artinya:

Setiap class yang menjadi subclass Account wajib menyediakan deposit() dan withdraw().

Misalnya:

class SavingAccount extends Account {
  @override
  void deposit() {
    print("Saving deposit");
  }

  @override
  void withdraw() {
    print("Saving withdrawal");
  }
}

Kemudian:

class CurrentAccount extends Account {
  @override
  void deposit() {
    print("Current deposit");
  }

  @override
  void withdraw() {
    print("Current withdrawal");
  }
}

Perhatikan sesuatu yang menarik.

Account menentukan:

Apa yang harus tersedia.

Tetapi subclass menentukan:

Bagaimana cara melakukannya.

10. “What to do” vs “How to do”

Ini konsep yang sangat penting.

Abstract class:

abstract class Account {
  void withdraw();
}

Superclass berkata:

“Kamu harus punya withdraw().”

Superclass tidak menentukan cara implementasinya.

Kemudian:

class SavingAccount extends Account {
  @override
  void withdraw() {
    // aturan saving account
  }
}

Subclass menentukan bagaimana caranya.

Jadi:

Abstract class
      ↓
WHAT
"Apa yang harus dilakukan?"
      ↓
Subclass
      ↓
HOW
"Bagaimana cara melakukannya?"

11. Kenapa Tidak Langsung Buat Method Biasa?

Misalnya kita melakukan:

class Account {
  void withdraw() {
    print("Withdraw");
  }
}

Berarti semua subclass mendapatkan implementasi tersebut.

Tetapi mungkin kita tidak ingin memberikan implementasi umum.

Karena:

SavingAccount
→ cara withdraw berbeda

CurrentAccount
→ cara withdraw berbeda

InvestmentAccount
→ cara withdraw berbeda

Maka lebih tepat:

abstract class Account {
  void withdraw();
}

Dengan demikian kita mengatakan:

“Saya tidak tahu implementasi spesifiknya. Tetapi saya tahu semua jenis Account harus memiliki withdraw.”

12. Subclass Wajib Mengimplementasikan Abstract Method

Contoh:

abstract class Animal {
  void sound();
}

Kemudian:

class Cat extends Animal {
}

Ini error.

Karena Cat belum menyediakan:

sound()

Harus:

class Cat extends Animal {
  @override
  void sound() {
    print("Meow");
  }
}

Baru valid.

13. Bagaimana Kalau Abstract Class Punya Concrete Method?

Misalnya:

abstract class Animal {
  void sound();

  void eat() {
    print("Animal is eating");
  }
}

Kemudian:

class Cat extends Animal {
  @override
  void sound() {
    print("Meow");
  }
}

Cat wajib membuat:

sound()

Tetapi tidak wajib membuat ulang:

eat()

Karena eat() sudah memiliki implementasi.

Jadi:

Abstract method
→ WAJIB diimplementasikan

Concrete method
→ TIDAK WAJIB di-override

14. Contoh Lengkap: Shape

Sekarang kita masuk ke contoh yang mirip dengan transcript.

Kita punya berbagai bentuk:

Shape
 ├── Rectangle
 └── Triangle

Kita tahu semua shape memiliki:

area

Tetapi cara menghitung area berbeda.

Rectangle:

panjang × lebar

Triangle:

½ × alas × tinggi

Maka kita bisa membuat:

abstract class Shape {
  double area();
}

Kemudian:

class Rectangle extends Shape {
  double width;
  double height;

  Rectangle(this.width, this.height);

  @override
  double area() {
    return width * height;
  }
}

Triangle:

class Triangle extends Shape {
  double base;
  double height;

  Triangle(this.base, this.height);

  @override
  double area() {
    return 0.5 * base * height;
  }
}

Penggunaan:

void main() {
  Rectangle rectangle = Rectangle(10, 5);
  Triangle triangle = Triangle(10, 4);

  print(rectangle.area());
  print(triangle.area());
}

Output:

50
20

15. Kenapa Shape dibuat abstract?

Karena kita tidak benar-benar ingin membuat:

Shape shape = Shape();

Kita hanya ingin mengatakan:

“Semua bentuk harus memiliki kemampuan menghitung area.”

Tetapi Shape sendiri tidak tahu rumus area spesifiknya.

Maka:

abstract class Shape {
  double area();
}

sangat cocok.

16. Abstract Class Bisa Memiliki Constructor

Ini juga penting.

Banyak pemula berpikir:

“Kalau abstract class tidak bisa dibuat object, berarti tidak boleh punya constructor.”

Salah.

Abstract class boleh memiliki constructor.

Contoh:

abstract class Shape {
  double width;
  double height;

  Shape(this.width, this.height);

  double area();
}

Constructor:

Shape(this.width, this.height);

tetap valid.

17. Lalu Kapan Constructor Abstract Class Dipanggil?

Saat kita membuat object dari subclass.

Misalnya:

abstract class Shape {
  Shape() {
    print("Shape constructor");
  }

  double area();
}

Kemudian:

class Rectangle extends Shape {
  Rectangle() {
    print("Rectangle constructor");
  }

  @override
  double area() {
    return 100;
  }
}

Kemudian:

void main() {
  Rectangle rectangle = Rectangle();
}

Output:

Shape constructor
Rectangle constructor

Urutannya:

Rectangle()
   ↓
Shape constructor
   ↓
Rectangle constructor

Kenapa?

Karena Rectangle adalah subclass dari Shape.

Object Rectangle juga harus melalui proses inisialisasi bagian Shape.

18. Bagaimana Kalau Constructor Abstract Class Punya Parameter?

Misalnya:

abstract class Shape {
  double width;
  double height;

  Shape(this.width, this.height);

  double area();
}

Kemudian subclass:

class Rectangle extends Shape {
  Rectangle(double width, double height)
      : super(width, height);

  @override
  double area() {
    return width * height;
  }
}

Perhatikan:

: super(width, height)

Ini berarti:

“Panggil constructor superclass Shape dengan parameter width dan height.”

Jadi:

Rectangle(10, 5)

alur sederhananya:

Rectangle(10, 5)
       ↓
super(10, 5)
       ↓
Shape(10, 5)
       ↓
width = 10
height = 5
       ↓
selesai inisialisasi Shape
       ↓
lanjut Rectangle

19. Ini Berkaitan dengan Materi super Sebelumnya

Kamu baru saja mempelajari super.

Ingat:

super.method()

digunakan untuk mengakses member superclass.

Sedangkan:

super(...)

digunakan untuk memanggil constructor superclass.

Contoh:

class Rectangle extends Shape {
  Rectangle(double width, double height)
      : super(width, height);
}

Di sini:

super(width, height)

bukan memanggil method.

Itu memanggil constructor Shape.

20. Abstract Class dengan Constructor + Concrete Method + Abstract Method

Sekarang kita gabungkan semuanya.

abstract class Shape {
  double width;
  double height;

  Shape(this.width, this.height);

  double area();

  void showSize() {
    print("Width: $width");
    print("Height: $height");
  }
}

Di sini Shape memiliki tiga jenis hal:

Field

double width;
double height;

Constructor

Shape(this.width, this.height);

Abstract method

double area();

Concrete method

void showSize() {
  print("Width: $width");
  print("Height: $height");
}

Kemudian:

class Rectangle extends Shape {
  Rectangle(double width, double height)
      : super(width, height);

  @override
  double area() {
    return width * height;
  }
}

Kita bisa:

void main() {
  final rectangle = Rectangle(10, 5);

  rectangle.showSize();
  print(rectangle.area());
}

Output:

Width: 10
Height: 5
50

21. Abstract Class dan Polymorphism

Di sinilah abstract class menjadi sangat kuat.

Kita bisa membuat:

abstract class Shape {
  double area();
}

Kemudian:

class Rectangle extends Shape {
  @override
  double area() {
    return 50;
  }
}

dan:

class Triangle extends Shape {
  @override
  double area() {
    return 20;
  }
}

Kemudian kita bisa memiliki:

void printArea(Shape shape) {
  print(shape.area());
}

Panggil:

printArea(Rectangle());
printArea(Triangle());

Meskipun parameter function adalah:

Shape shape

object yang diberikan bisa:

Rectangle
Triangle

dan method area() akan berjalan sesuai object sebenarnya.

Ini adalah polymorphism.

Jadi hubungan konsepnya:

Abstract class
      ↓
Abstract method
      ↓
Subclass wajib override
      ↓
Method overriding
      ↓
Polymorphism

22. Abstract Class sebagai “Blueprint Aturan”

Cara lain membayangkannya:

          Shape
     abstract class
             |
       area() wajib ada
         /         \
        /           \
 Rectangle        Triangle
    |                 |
 area()              area()
rumus rectangle    rumus triangle

Shape tidak peduli bagaimana area dihitung.

Dia hanya menetapkan:

“Kalian harus punya area().”

23. Pertanyaan: Kenapa Abstract Class Tidak Bisa Di-instansiasi?

Transcript memberikan alasan bahwa abstract method tidak memiliki sesuatu untuk dieksekusi.

Untuk pemahaman pemula, itu cukup sebagai intuisi.

Tetapi secara konsep yang lebih tepat:

Abstract class memang dirancang sebagai class yang belum lengkap untuk digunakan sebagai concrete object.

Contohnya:

abstract class Shape {
  double area();
}

Shape adalah konsep umum.

Tidak jelas bentuk konkretnya:

Shape apa?
Rectangle?
Circle?
Triangle?

Karena itu kita membuat subclass:

Rectangle
Circle
Triangle

yang memberikan implementasi nyata.

24. Abstract Class Bisa Memiliki Semua Concrete Method

Misalnya:

abstract class Animal {
  void eat() {
    print("Eating");
  }

  void sleep() {
    print("Sleeping");
  }
}

Tidak ada abstract method sama sekali.

Tetapi tetap valid sebagai:

abstract class Animal

Dan tetap tidak bisa:

Animal(); // ERROR

Kenapa seseorang melakukan ini?

Misalnya kita memang ingin class tersebut hanya menjadi base class, bukan class yang boleh dibuat langsung.

25. Abstract Class Bisa Memiliki Semua Abstract Method

Contoh:

abstract class Animal {
  void sound();
  void move();
  void eat();
}

Semua method abstract.

Subclass harus mengimplementasikan semuanya.

26. extends vs implements pada Abstract Class

Ini bagian yang sangat penting karena transcript membahasnya.

Misalnya:

abstract class Animal {
  void sound();

  void eat() {
    print("Eating");
  }
}

Kalau:

class Cat extends Animal {
  @override
  void sound() {
    print("Meow");
  }
}

Dengan extends, Cat:

• mewarisi implementasi eat()
• wajib mengimplementasikan sound()

Jadi:

extends
   ↓
mewarisi implementasi
   +
wajib implementasi abstract members

27. Kalau Menggunakan implements

Misalnya:

class Cat implements Animal {
  @override
  void sound() {
    print("Meow");
  }

  @override
  void eat() {
    print("Cat is eating");
  }
}

Perhatikan:

eat() juga harus dibuat ulang.

Kenapa?

Karena implements berarti:

“Saya mengikuti interface dari class tersebut.”

Bukan:

“Saya mewarisi implementasinya.”

Jadi secara sederhana:

extends

Animal
   ↓
Cat

Cat mendapatkan implementation yang diwariskan.

implements

Animal
   ↓
Cat

Cat mengikuti kontraknya,
tetapi harus menyediakan implementasinya sendiri.

Ini penting untuk memahami interface Dart.

28. Koreksi Penting tentang implements

Transcript mengatakan:

“Ketika implement abstract class, semua method harus diimplementasikan.”

Untuk konteks Dart, pemahaman tersebut benar secara praktis.

Jika:

abstract class Animal {
  void sound();

  void eat() {
    print("Eating");
  }
}

lalu:

class Cat implements Animal {
}

maka Cat harus menyediakan implementasi untuk semua instance members yang menjadi interface, termasuk sound() dan eat().

Jadi implements berbeda dengan extends.

29. Kalau Subclass Tidak Mengimplementasikan Abstract Method?

Misalnya:

abstract class Animal {
  void sound();
}

Kemudian:

class Cat extends Animal {
}

Error.

Karena Cat adalah class concrete tetapi masih memiliki:

sound()

yang abstract.

30. Tapi Ada Cara: Subclass Juga Dibuat Abstract

Ini bagian menarik.

Kita bisa:

abstract class Animal {
  void sound();
}

Kemudian:

abstract class Cat extends Animal {
}

Ini valid.

Kenapa?

Karena Cat juga abstract.

Jadi Cat belum diwajibkan memberikan implementasi final.

Strukturnya:

Animal
abstract
   |
   ↓
Cat
abstract
   |
   ↓
PersianCat
concrete

Misalnya:

abstract class Animal {
  void sound();
}

abstract class Cat extends Animal {
  void scratch();
}

class PersianCat extends Cat {
  @override
  void sound() {
    print("Meow");
  }

  @override
  void scratch() {
    print("Scratch");
  }
}

PersianCat harus lengkap karena dia concrete.

31. Static Member dalam Abstract Class

Abstract class juga boleh memiliki static member.

Contoh:

abstract class Config {
  static const String appName = "My App";

  static void showAppName() {
    print(appName);
  }
}

Kita tidak perlu membuat object:

Config.showAppName();

atau:

print(Config.appName);

Kenapa?

Karena static member milik class, bukan object.

Jadi meskipun:

Config

adalah abstract dan tidak bisa dibuat object, static member tetap bisa digunakan melalui nama class.

32. Jangan Pakai super untuk Static Member

Ini berkaitan dengan materi sebelumnya.

Misalnya:

abstract class A {
  static int x = 10;
}

Kemudian:

class B extends A {
  void show() {
    print(super.x); // ERROR
  }
}

Tidak boleh.

Static member diakses melalui nama class:

print(A.x);

Karena:

instance member
→ berkaitan dengan object
→ bisa menggunakan super

static member
→ berkaitan dengan class
→ gunakan nama class

33. Getter dan Setter di Abstract Class

Abstract class juga boleh memiliki getter dan setter.

Misalnya:

abstract class Person {
  String _name = "Unknown";

  String get name {
    return _name;
  }

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

Kemudian:

class Employee extends Person {}

Kita bisa:

void main() {
  final employee = Employee();

  employee.name = "Sam";

  print(employee.name);
}

Output:

Sam

Kenapa bisa?

Karena Employee mewarisi getter dan setter dari Person.

34. Getter/Setter Tidak Harus Static

Ini juga perlu diperhatikan.

Getter/setter:

String get name => _name;

set name(String value) => _name = value;

adalah instance members.

Jadi digunakan melalui object:

employee.name

Sedangkan static:

static String get appName => "My App";

digunakan:

Person.appName

35. Abstract Class di Flutter

Konsep ini benar-benar digunakan di Flutter.

Beberapa class/framework API Flutter menggunakan abstract class.

Contoh yang sangat penting adalah Widget.

Secara konsep:

abstract class Widget {
  ...
}

Kemudian kita membuat:

class MyWidget extends StatelessWidget {
  ...
}

Dan:

StatelessWidget

sendiri merupakan bagian dari hierarchy widget Flutter.

Kita sebagai developer tidak membuat object dari abstract base class secara sembarangan.

Kita menggunakan subclass atau implementasi konkret yang sesuai.

36. Contoh Flutter yang Sangat Penting

Misalnya:

class MyPage extends StatelessWidget {
  const MyPage({super.key});

  @override
  Widget build(BuildContext context) {
    return const Text("Hello");
  }
}

Perhatikan:

@override
Widget build(BuildContext context)

Ini adalah konsep overriding.

StatelessWidget memiliki kontrak/behavior tertentu, dan subclass kita memberikan implementasinya.

Jadi konsep OOP yang baru kita pelajari langsung muncul di Flutter.

37. Hubungan Semua Materi OOP yang Sudah Dipelajari

Materi ini sebenarnya menyambungkan banyak topik sebelumnya.

Urutannya:

Class
 ↓
Inheritance
 ↓
Abstract Class
 ↓
Abstract Method
 ↓
Method Overriding
 ↓
Polymorphism

Contoh:

abstract class Animal {
  void sound();
}

Animal:

abstract class

sound():

abstract method

Kemudian:

class Cat extends Animal {
  @override
  void sound() {
    print("Meow");
  }
}

Cat extends Animal:

inheritance

@override:

method overriding

Kemudian:

Animal animal = Cat();
animal.sound();

Ini:

polymorphism

Output:

Meow

38. Bedakan 4 Istilah Ini

Ini wajib kamu kuasai.

1. Abstract class

abstract class Animal {}

Class yang tidak dapat dibuat object secara langsung.

2. Abstract method

void sound();

Method tanpa implementasi.

3. Concrete class

class Cat extends Animal {}

Class yang bisa dibuat object selama tidak menyisakan abstract member yang wajib diimplementasikan.

4. Concrete method

void eat() {
  print("Eating");
}

Method yang sudah memiliki implementasi.

39. Analogi Sederhana: Kontrak Kerja

Bayangkan sebuah perusahaan membuat kontrak:

INTERFACE PEKERJAAN

Setiap programmer harus:
1. coding()
2. testing()
3. debugging()

Kontrak tidak menjelaskan:

“Bagaimana cara setiap programmer melakukannya?”

Dia hanya menetapkan:

“Tugas tersebut harus ada.”

Dalam Dart:

abstract class Programmer {
  void coding();
  void testing();
  void debugging();
}

Kemudian:

class FlutterDeveloper extends Programmer {
  @override
  void coding() {
    print("Coding with Flutter");
  }

  @override
  void testing() {
    print("Testing Flutter app");
  }

  @override
  void debugging() {
    print("Debugging Flutter app");
  }
}

Abstract class = kontrak/aturan.

Subclass = pelaksana aturan.

40. Analogi Restoran

Misalnya ada aturan:

Setiap restoran harus punya:
- order()
- pay()

Abstract:

abstract class Restaurant {
  void order();
  void pay();
}

Kemudian:

class FastFoodRestaurant extends Restaurant {
  @override
  void order() {
    print("Order through counter");
  }

  @override
  void pay() {
    print("Pay at cashier");
  }
}

Restoran lain:

class OnlineRestaurant extends Restaurant {
  @override
  void order() {
    print("Order through app");
  }

  @override
  void pay() {
    print("Pay online");
  }
}

Aturannya sama:

order()
pay()

Tetapi implementasinya berbeda.

Itulah inti abstract method.

41. 10 Poin Penting dari Video

Mari kita rangkum pertanyaan-pertanyaan di transcript.

1. Mengapa abstract class tidak bisa diinstansiasi?

Karena abstract class adalah base class yang belum dimaksudkan sebagai concrete object dan dapat memiliki abstract member yang belum memiliki implementasi.

2. Apakah abstract class boleh punya constructor?

Boleh.

Bahkan boleh punya beberapa constructor, mengikuti aturan constructor Dart.

3. Kapan constructor abstract class dipanggil?

Ketika constructor subclass dibuat dan memanggil constructor superclass.

Contoh:

abstract class A {
  A() {
    print("A");
  }
}

class B extends A {
  B() {
    print("B");
  }
}

B();

Output:

A
B

4. Apakah abstract class bisa di-implements?

Bisa.

abstract class A {
  void test();

  void show() {
    print("Show");
  }
}

class B implements A {
  @override
  void test() {
    print("Test");
  }

  @override
  void show() {
    print("Show B");
  }
}

Dengan implements, semua interface member yang relevan harus disediakan implementasinya.

5. Apakah abstract class harus memiliki abstract method?

Tidak.

Bisa:

abstract class A {
  void test() {}
}

Tidak ada abstract method, tetapi tetap abstract class.

6. Apa kegunaan abstract class?

Terutama untuk membuat:

• kontrak
• aturan
• base class
• struktur umum
• API yang harus diikuti subclass
• fondasi polymorphism

7. Apakah Flutter menggunakan abstract class?

Ya.

Framework Flutter memiliki berbagai abstract/base API dan hierarchy class yang menggunakan konsep abstraksi.

8. Apa yang terjadi jika subclass tidak mengimplementasikan abstract method?

Kalau subclass tersebut concrete, akan terjadi compile-time error.

Tetapi subclass bisa tetap dibuat abstract:

abstract class Child extends Parent {}

Sehingga implementasinya bisa ditunda ke subclass berikutnya.

9. Apakah abstract class boleh memiliki static member?

Boleh.

Contoh:

abstract class Config {
  static const appName = "My App";
}

Akses:

Config.appName

Tidak perlu object.

10. Apakah abstract class boleh memiliki getter/setter?

Boleh.

Contoh:

abstract class Person {
  String _name = "";

  String get name => _name;

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

Subclass dapat menggunakan getter/setter tersebut jika diwariskan atau diakses sesuai visibility.

42. Hal yang Perlu Kamu Hafalkan

Kalau ingin versi paling singkat, hafalkan tabel ini:

43. Pola yang Sangat Sering Kamu Temui

Kamu akan sering melihat pola seperti ini:

abstract class Animal {
  void sound();
}

↓

class Cat extends Animal {
  @override
  void sound() {
    print("Meow");
  }
}

↓

class Dog extends Animal {
  @override
  void sound() {
    print("Woof");
  }
}

↓

void makeSound(Animal animal) {
  animal.sound();
}

↓

makeSound(Cat());
makeSound(Dog());

Output:

Meow
Woof

Inilah kombinasi:

Abstract Class + Abstract Method + Inheritance + Overriding + Polymorphism.

Kesimpulan paling penting

Jangan menganggap abstract class sebagai “class yang kosong”. Lebih tepat melihatnya sebagai fondasi atau kontrak untuk class-class turunannya.

Misalnya:

abstract class Shape {
  double area();
}

Artinya bukan:

“Shape tidak tahu apa-apa.”

Tetapi:

“Shape menetapkan bahwa setiap bentuk harus memiliki area(), sementara masing-masing subclass bertanggung jawab menentukan cara menghitungnya.”

Sehingga:

                 Shape
           abstract class
                  │
             area() wajib
                  │
        ┌─────────┴─────────┐
        ↓                   ↓
   Rectangle             Triangle
        │                   │
   area = p × l        area = ½ × a × t

Dan ketika kamu sudah memahami ini, abstract class sebenarnya menjadi sangat mudah: ia adalah cara Dart untuk mengatakan “ini aturan yang harus dipenuhi subclass, tetapi detail implementasinya diserahkan kepada subclass.”