Materi kali ini membahas Abstraction (abstraksi) dalam OOP Dart, lalu masuk ke abstract class, interface, serta perbedaan extends dan implements. Saya akan mengikuti isi materi yang kamu kirim, sambil meluruskan beberapa istilah caption yang salah seperti “DOT” → Dart, “overwrite” → override, dan “implements” yang kadang tertulis tidak jelas.

1. Apa itu Abstraction?

Abstraction = abstraksi, yaitu konsep untuk:

Menyembunyikan detail implementasi yang tidak perlu diketahui pengguna, dan hanya menampilkan bagian yang penting.

Materi menjelaskan bahwa abstraction merupakan salah satu fitur/pilar OOP selain:

• Class
• Object
• Encapsulation
• Inheritance
• Polymorphism
• Abstraction

Analogi sederhana

Bayangkan kamu menggunakan mesin ATM.

Kamu cukup melihat:

Masukkan kartu
      ↓
Masukkan PIN
      ↓
Pilih tarik tunai
      ↓
Masukkan jumlah
      ↓
Ambil uang

Kamu tidak perlu tahu:

Bagaimana database bekerja?
Bagaimana saldo dicari?
Bagaimana koneksi bank dilakukan?
Bagaimana transaksi dicatat?

Detail tersebut disembunyikan.

Yang diberikan kepada pengguna hanyalah fitur yang diperlukan.

Itulah ide abstraction.

2. Contoh sederhana abstraction dalam kehidupan nyata

Misalnya ada kendaraan.

Kita tahu mobil memiliki kemampuan:

start()
stop()
drive()

Kita tidak harus mengetahui secara detail bagaimana mesin membakar bahan bakar, bagaimana piston bergerak, dan sebagainya.

Dalam programming, kita bisa membuat konsep:

abstract class Vehicle {
  void start();
  void stop();
}

Kita mengatakan:

“Setiap Vehicle harus mempunyai start() dan stop(), tetapi cara melakukannya terserah class turunannya.”

Jadi abstraction lebih fokus kepada:

“Apa yang harus bisa dilakukan?”

daripada:

“Bagaimana cara melakukannya?”

3. Apa itu abstract class?

Kata kuncinya:

abstract

Contoh:

abstract class Person {
}

Artinya Person adalah abstract class.

Abstract class biasanya digunakan sebagai blueprint/pedoman untuk class lain.

Materi menjelaskan bahwa abstract class tidak bisa dibuat object secara langsung.

Misalnya:

abstract class Person {
}

Kita tidak boleh:

Person person = Person(); // ❌

Karena Person adalah abstract class.

Tetapi kita bisa membuat:

class Student extends Person {
}

Lalu:

Student student = Student(); // ✅

4. Kenapa abstract class tidak bisa dibuat object?

Pikirkan abstract class sebagai blueprint yang belum lengkap.

Misalnya kita membuat:

abstract class Animal {
  void makeSound();
}

Kita belum menentukan suara binatangnya.

Karena:

Animal
  ↓
???? suara apa?

Apakah:

Cat → Meow
Dog → Woof
Cow → Moo

Maka Animal hanya memberikan aturan:

“Semua animal harus memiliki makeSound().”

Tetapi implementasinya diberikan kepada class anak.

5. Apa itu abstract method?

Ini sangat penting.

Abstract method adalah method yang tidak memiliki body/implementation.

Contoh:

abstract class Person {
  void canRun();

  void canEat();
}

Perhatikan:

void canRun();

Tidak ada:

{
   ...
}

Jadi belum ada implementasinya.

Materi juga menjelaskan bahwa method tanpa body disebut abstract method.

6. Abstract method harus diimplementasikan oleh child

Misalnya:

abstract class Person {
  void canRun();
  void canEat();
}

Kemudian:

class Student extends Person {
}

Dart akan memberikan error.

Kenapa?

Karena Student belum menyediakan implementasi:

Person
├── canRun() ❓
└── canEat() ❓

Student
└── belum mengimplementasikan keduanya

Maka kita harus membuat:

class Student extends Person {
  @override
  void canRun() {
    print("Student can run");
  }

  @override
  void canEat() {
    print("Student can eat");
  }
}

Sekarang sudah lengkap.

7. Apa fungsi @override?

Kita sudah bertemu override pada materi inheritance sebelumnya.

@override berarti:

“Method ini adalah implementasi/penggantian method yang berasal dari parent.”

Contoh:

abstract class Person {
  void canRun();
}

Kemudian:

class Student extends Person {
  @override
  void canRun() {
    print("Student can run");
  }
}

Jadi:

Person
└── canRun()   ← aturan

        ↓ extends

Student
└── canRun()   ← implementasi

@override membantu compiler dan pembaca kode memahami bahwa kita memang sedang mengimplementasikan method dari parent.

8. Abstract class bisa mempunyai concrete method

Ini salah satu poin penting dari video.

Abstract class tidak berarti semua method harus abstract.

Abstract class bisa memiliki:

1. Abstract method
2. Concrete method

Abstract method

Tidak punya body:

void canRun();

Concrete method

Punya body:

void canEat() {
  print("Person can eat");
}

Contohnya:

abstract class Person {
  void canRun();

  void canEat() {
    print("Person can eat");
  }
}

Sekarang canRun() abstract, sedangkan canEat() concrete.

Materi juga menunjukkan bahwa concrete method tidak wajib di-override oleh child.

9. Contoh lengkap abstract class

abstract class Person {
  void canRun();

  void canEat() {
    print("Person can eat");
  }
}

class Student extends Person {
  @override
  void canRun() {
    print("Student can run");
  }
}

void main() {
  Student student = Student();

  student.canRun();
  student.canEat();
}

Output:

Student can run
Person can eat

Kenapa canEat() bisa dipanggil?

Karena canEat() sudah memiliki implementation di Person.

Sedangkan canRun() harus dibuat oleh Student.

10. Jadi, aturan abstract class seperti apa?

Bayangkan:

abstract class Person {
  void canRun();
  void canEat() {
    print("Person can eat");
  }
}

Maka:

Ini inti yang perlu kamu pahami.

11. Abstract class dan object

Ini juga sangat penting.

abstract class Person {
  void sayHello();
}

Tidak boleh:

Person person = Person(); // ❌

Tetapi:

class Student extends Person {
  @override
  void sayHello() {
    print("Hello");
  }
}

Boleh:

Student student = Student(); // ✅

Jadi:

Abstract class
     ↓
   blueprint
     ↓
tidak langsung dibuat object
     ↓
Child class
     ↓
implementasi lengkap
     ↓
bisa dibuat object

Materi juga memperlihatkan error ketika mencoba membuat object dari abstract class.

12. Sekarang masuk ke Interface

Bagian berikutnya membahas interface.

Secara sederhana:

Interface adalah kontrak/aturan yang harus dipenuhi oleh sebuah class.

Misalnya bank memiliki aturan:

Bank harus bisa:
- deposit()
- withdraw()

Kita bisa membuat:

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

Kemudian bank tertentu harus mengimplementasikan aturan tersebut.

Misalnya:

class HBL implements Bank {
  @override
  void deposit() {
    print("Deposit done");
  }

  @override
  void withdraw() {
    print("Withdraw done");
  }
}

13. implements artinya apa?

Kalau:

class HBL implements Bank

artinya:

“Class HBL berjanji akan mengikuti kontrak/interface Bank.”

Karena Bank mempunyai:

void deposit();
void withdraw();

maka HBL wajib menyediakan keduanya.

class HBL implements Bank {
  @override
  void deposit() {
    print("Deposit done");
  }

  @override
  void withdraw() {
    print("Withdraw done");
  }
}

14. Contoh dua bank

Misalnya:

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

Kita punya:

class HBL implements Bank {
  @override
  void deposit() {
    print("HBL deposit done");
  }

  @override
  void withdraw() {
    print("HBL withdraw done");
  }
}

Dan:

class MCB implements Bank {
  @override
  void deposit() {
    print("MCB deposit done");
  }

  @override
  void withdraw() {
    print("MCB withdraw done");
  }
}

Keduanya mempunyai aturan yang sama:

Bank
├── deposit()
└── withdraw()

       ↓ implements

HBL
├── deposit()
└── withdraw()

MCB
├── deposit()
└── withdraw()

Tetapi implementasinya bisa berbeda.

15. Interface di Dart sedikit berbeda dengan bahasa lain

Ini bagian yang perlu diperhatikan.

Materi mengatakan bahwa di beberapa bahasa ada keyword khusus untuk membuat interface, tetapi Dart tidak menggunakan keyword interface seperti beberapa bahasa lain.

Dalam Dart, sebuah class secara umum dapat digunakan sebagai interface.

Misalnya:

class Bank {
  void deposit() {}
  void withdraw() {}
}

Kemudian:

class HBL implements Bank {
  @override
  void deposit() {
    print("Deposit");
  }

  @override
  void withdraw() {
    print("Withdraw");
  }
}

Jadi jangan berpikir:

interface = keyword interface

seperti di beberapa bahasa lain.

Di Dart, konsep interface lebih berkaitan dengan penggunaan implements.

16. Perbedaan paling penting: extends vs implements

Nah, ini adalah inti besar dari materi.

Keduanya sama-sama berhubungan dengan class lain, tetapi konsepnya berbeda.

extends

class Student extends Person

Artinya:

Student mewarisi dari Person.

Student mendapatkan behavior/implementation yang tersedia dari Person.

Misalnya:

class Person {
  void eat() {
    print("Person eats");
  }
}

class Student extends Person {
}

Maka:

Student student = Student();

student.eat();

bisa berjalan.

Karena eat() diwarisi dari Person.

implements

class Student implements Person

Artinya:

Student mengikuti kontrak/interface Person.

Implementation dari Person tidak diwariskan sebagai behavior.

Student harus menyediakan implementasinya sendiri untuk member yang diwajibkan.

17. Analogi extends vs implements

Bayangkan ada guru memberikan buku.

extends

Kamu mendapatkan buku tersebut dan menggunakan isi yang sudah ada.

Person
  ↓
Student

Student mewarisi implementation dari Person.

implements

Guru hanya memberikan daftar aturan:

Harus bisa:
✓ makan
✓ berjalan
✓ berbicara

Kamu harus membuat implementasinya sendiri.

Person
  ↓
aturan/kontrak
  ↓
Student
  ↓
implementasi sendiri

Jadi:

extends = mewarisi.

implements = memenuhi kontrak.

18. Perbedaan pertama: multiple inheritance

Materi memberikan contoh dua class:

abstract class Rectangle {
  void height();
}

abstract class Square {
  void width();
}

Kemudian kita ingin membuat:

MyShape

dan mengambil keduanya.

Dengan extends:

class MyShape extends Rectangle, Square {
}

❌ Tidak diperbolehkan.

Dart tidak mendukung multiple inheritance class seperti itu.

19. Tetapi implements bisa lebih dari satu

Kita bisa:

class MyShape implements Rectangle, Square {
  @override
  void height() {
    print("Height");
  }

  @override
  void width() {
    print("Width");
  }
}

Sekarang:

Rectangle
   │
   └── height()

Square
   │
   └── width()

      ↓ implements

MyShape
├── height()
└── width()

Materi menunjukkan bahwa implements memungkinkan satu class mengimplementasikan beberapa interface.

Ini salah satu kelebihan penting implements.

20. Perbedaan kedua: constructor

Ini bagian yang sering membingungkan.

Misalnya:

class Person {
  Person() {
    print("Person constructor");
  }
}

Kemudian:

class Student extends Person {
  Student() {
    print("Student constructor");
  }
}

Ketika:

Student student = Student();

constructor parent akan dijalankan terlebih dahulu.

Output:

Person constructor
Student constructor

Urutannya:

Student()
   ↓
Person constructor
   ↓
Student constructor

Materi juga menunjukkan urutan ini untuk extends.

21. Kenapa parent constructor dijalankan?

Karena dengan extends, Student benar-benar merupakan turunan dari Person.

Bagian Person dari object tersebut perlu diinisialisasi terlebih dahulu.

Contoh:

class Person {
  String name;

  Person(this.name);
}

Kemudian:

class Student extends Person {
  int marks;

  Student(String name, this.marks) : super(name);
}

Ketika:

Student student = Student("Budi", 90);

alur sederhananya:

Student("Budi", 90)
        ↓
super("Budi")
        ↓
Person constructor
        ↓
name = "Budi"
        ↓
Student constructor
        ↓
marks = 90

22. Bagaimana dengan implements?

Misalnya:

class Person {
  Person() {
    print("Person constructor");
  }
}

Kemudian:

class Student implements Person {
  Student() {
    print("Student constructor");
  }

  @override
  // implementasi member yang diperlukan
}

Student tidak mewarisi implementation/constructor Person melalui implements.

Jadi constructor Person tidak otomatis dipanggil.

Ini sesuai demonstrasi dalam materi.

23. Perbedaan ketiga: super

Ini juga sangat penting.

Dengan extends, kita bisa menggunakan:

super

Misalnya:

class Rectangle {
  void getHeight() {
    print("Height of Rectangle");
  }
}

class MyShape extends Rectangle {
  @override
  void getHeight() {
    print("Height of MyShape");
  }
}

Kalau:

MyShape shape = MyShape();

shape.getHeight();

hasil:

Height of MyShape

Karena method child melakukan override.

24. Kalau ingin memanggil method parent?

Gunakan:

super.getHeight();

Contoh:

class MyShape extends Rectangle {
  @override
  void getHeight() {
    super.getHeight();

    print("Height of MyShape");
  }
}

Output:

Height of Rectangle
Height of MyShape

Jadi:

super.getHeight();

berarti:

“Panggil implementation getHeight() milik parent.”

Materi juga menunjukkan penggunaan super untuk memanggil method parent ketika menggunakan extends.

25. Kenapa super tidak berlaku seperti itu pada implements?

Karena:

implements

tidak berarti:

“Saya mewarisi implementation dari parent.”

Melainkan:

“Saya mengikuti interface/kontraknya.”

Jadi ketika:

class MyShape implements Rectangle

dan Rectangle memiliki:

void getHeight() {
  print("Height of Rectangle");
}

MyShape tidak mendapatkan implementation tersebut sebagai inherited behavior.

MyShape harus membuat sendiri:

@override
void getHeight() {
  print("Height of MyShape");
}

Karena tidak ada implementation parent yang diwarisi untuk dipanggil menggunakan super.

Materi menunjukkan bahwa penggunaan super.getHeight() dalam kasus implements menghasilkan error.

26. Jadi extends vs implements

Ini tabel yang sebaiknya kamu hafalkan:

27. Contoh perbandingan langsung

extends

class Person {
  void eat() {
    print("Person eats");
  }
}

class Student extends Person {
}

Kemudian:

Student student = Student();

student.eat();

Output:

Person eats

Karena eat() diwarisi.

implements

class Person {
  void eat() {
    print("Person eats");
  }
}

class Student implements Person {
  @override
  void eat() {
    print("Student eats");
  }
}

Sekarang Student harus membuat implementasi sendiri.

Student student = Student();

student.eat();

Output:

Student eats

28. Cara membedakan dalam kepala

Gunakan dua kata sederhana:

extends → “WARISI”

Person
   ↓
Student

Student mendapatkan apa yang dimiliki Person.

implements → “JANJI”

Person
   ↓
aturan
   ↓
Student

Student berkata:

“Saya akan memenuhi semua aturan Person.”

29. Hubungan dengan abstraction

Sekarang kita bisa melihat gambaran besarnya.

Abstraction:

Apa yang harus dilakukan?

Contoh:

abstract class Animal {
  void makeSound();
}

Kita tidak peduli bagaimana suara dibuat.

Kemudian:

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

dan:

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

Jadi:

             Animal
                │
          makeSound()
                │
       ┌────────┴────────┐
       ↓                 ↓
      Cat               Dog
       │                 │
      Meow              Woof

Parent menentukan aturan, child menentukan cara melakukan.

Itulah abstraction yang kemudian sangat berkaitan dengan polymorphism.

30. Gambaran besar seluruh materi

Kamu sekarang sudah belajar beberapa konsep OOP:

OOP
│
├── Class
│     └── blueprint
│
├── Object
│     └── instance dari class
│
├── Constructor
│     └── inisialisasi object
│
├── Encapsulation
│     └── mengontrol akses data
│
├── Inheritance
│     └── pewarisan
│
├── Polymorphism
│     └── banyak bentuk behavior
│
└── Abstraction
      └── menyembunyikan detail
          dan menentukan kontrak

Dan dalam abstraction:

Abstraction
│
├── Abstract Class
│      │
│      ├── Abstract Method
│      │      └── tanpa body
│      │
│      └── Concrete Method
│             └── punya body
│
└── Interface
       │
       └── implements

31. Contoh nyata: sistem pembayaran

Misalnya kita membuat aplikasi pembayaran.

Kita tidak ingin fungsi utama mengetahui detail setiap metode pembayaran.

Kita bisa membuat:

abstract class Payment {
  void pay();
}

Kemudian:

class CreditCardPayment implements Payment {
  @override
  void pay() {
    print("Pay using credit card");
  }
}

dan:

class BankTransferPayment implements Payment {
  @override
  void pay() {
    print("Pay using bank transfer");
  }
}

Sekarang aplikasi memiliki aturan umum:

Payment
   │
   └── pay()

Tetapi implementasinya berbeda:

CreditCardPayment
        ↓
Pay using credit card

BankTransferPayment
        ↓
Pay using bank transfer

Inilah kekuatan abstraction.

Kode yang menggunakan Payment tidak perlu mengetahui detail internal setiap metode pembayaran.

32. Kesalahan pemahaman yang perlu dihindari

❌ Salah 1

Abstract class berarti semua method harus abstract.

Tidak.

Abstract class bisa memiliki:

abstract method
+
concrete method

❌ Salah 2

Abstract class tidak bisa mempunyai constructor.

Tidak tepat.

Abstract class bisa memiliki constructor. Yang tidak boleh adalah membuat instance langsung dari abstract class.

❌ Salah 3

implements sama dengan extends.

Tidak.

extends    → inheritance
implements → contract/interface

❌ Salah 4

implements mengambil method parent.

Tidak seperti extends.

Dengan implements, class harus menyediakan implementation yang sesuai.

❌ Salah 5

Kalau menggunakan implements, kita bisa menggunakan super untuk memanggil implementation parent.

Tidak.

super untuk parent implementation berkaitan dengan inheritance melalui extends.

33. Ringkasan yang wajib kamu ingat

Kalau materi ini terasa banyak, cukup kuasai 7 poin utama berikut:

1. Abstraction

Menyembunyikan detail implementasi dan menampilkan hal yang penting.

2. Abstract class

abstract class Person {
}

Berfungsi sebagai blueprint dan tidak bisa langsung dibuat object.

3. Abstract method

void run();

Tidak mempunyai body.

4. Concrete method

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

Mempunyai body/implementation.

5. extends

class Student extends Person

Berarti mewarisi dari parent.

6. implements

class HBL implements Bank

Berarti memenuhi kontrak/interface dan harus menyediakan implementation yang diperlukan.

7. super

super.method();

Digunakan untuk mengakses implementation dari parent ketika menggunakan inheritance.

🧠 Cara paling gampang mengingat

Bayangkan ada aturan sekolah.

              Person
                │
        "Semua orang harus bisa
             eat() dan run()"
                │
       ┌────────┴────────┐
       ↓                 ↓
    Student            Teacher

Kalau menggunakan:

extends

artinya:

Student mewarisi kemampuan Person.

Kalau menggunakan:

implements

artinya:

Student berjanji mengikuti aturan Person dan membuat implementasinya sendiri.

Dan abstraction adalah ide yang mendasarinya:

Kita menentukan apa yang harus tersedia, tanpa memaksa pengguna mengetahui bagaimana detail internalnya bekerja.