Materi ini melanjutkan pembahasan sebelumnya tentang abstract class, tetapi sekarang fokusnya adalah interface di Dart.

Topik ini memang sedikit membingungkan pada awalnya karena Dart tidak memiliki keyword interface khusus seperti Java atau C#. Namun justru konsepnya sangat menarik: setiap class di Dart secara otomatis bisa berperan sebagai interface.

Saya akan jelaskan dari dasar, lalu kita hubungkan dengan extends, implements, abstract class, overriding, dan polymorphism.

1. Apa itu Interface?

Secara sederhana:

Interface adalah kontrak yang menentukan member apa saja yang harus disediakan oleh sebuah class.

Misalnya kita membuat aturan:

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

  void sound() {
    print("Animal sound");
  }
}

Class tersebut bisa digunakan sebagai interface.

Kemudian:

class Cat implements Animal {
  @override
  void eat() {
    print("Cat eating");
  }

  @override
  void sound() {
    print("Meow");
  }
}

Artinya:

Animal
   ↓
interface/kontrak
   ↓
Cat
   ↓
harus menyediakan member yang diwajibkan

Cara mudah mengingatnya:

Interface = WHAT Implementing class = HOW

Interface mengatakan:

“Kamu harus punya method sound().”

Class yang mengimplementasikannya mengatakan:

“Oke, saya akan menentukan bagaimana sound() bekerja.”

2. Dart Tidak Memiliki Keyword interface

Ini perbedaan penting dengan beberapa bahasa seperti Java.

Di Java, kita bisa menulis:

interface Animal {
    ...
}

Sedangkan di Dart tidak ada cara seperti:

interface Animal { } // tidak ada keyword seperti ini

Sebagai gantinya, class biasa dapat digunakan sebagai interface.

Contoh:

class Animal {
  void sound() {
    print("Animal sound");
  }
}

Kemudian:

class Cat implements Animal {
  ...
}

Jadi:

Dart class
   ↓
secara otomatis dapat berperan sebagai interface

Inilah yang sering disebut:

Implicit interface

3. extends vs implements

Ini bagian paling penting dari materi ini.

Misalnya:

class Animal {
  void sound() {
    print("Animal sound");
  }
}

Ada dua cara menggunakan Animal.

Dengan extends

class Cat extends Animal {
}

Artinya:

“Cat adalah subclass dari Animal dan mewarisi implementasi yang tersedia.”

Jadi:

final cat = Cat();

cat.sound();

Output:

Animal sound

Karena Cat mendapatkan method sound() dari Animal.

Dengan implements

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

Artinya:

“Cat menggunakan Animal sebagai kontrak/interface.”

Cat tidak mendapatkan implementasi method sound() dari Animal.

Cat harus menyediakan implementasinya sendiri.

4. Analogi extends dan implements

Bayangkan ada guru memberikan buku resep.

extends

Seolah-olah kamu berkata:

“Saya menggunakan resep milik guru dan boleh memakainya.”

implements

Seolah-olah kamu berkata:

“Saya mengikuti standar resep guru, tetapi saya harus menyediakan resep saya sendiri.”

Jadi:

extends
↓
mewarisi implementation

implements
↓
mengikuti contract/interface

5. Contoh Perbedaan yang Sangat Jelas

Kita punya:

class Animal {
  void sound() {
    print("Animal sound");
  }

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

extends

class Cat extends Animal {
}

Cat otomatis mendapatkan:

sound()
eat()

Jadi:

final cat = Cat();

cat.sound();
cat.eat();

Bisa langsung digunakan.

implements

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

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

Keduanya harus dibuat ulang.

Ini inti dari implements.

6. Kenapa Semua Instance Member Harus Diimplementasikan?

Misalnya:

class Animal {
  int age = 10;

  void sound() {
    print("Animal sound");
  }
}

Kemudian:

class Cat implements Animal {
}

Ini error.

Karena Cat belum memenuhi kontrak Animal.

Ada:

age
sound()

yang merupakan instance members.

Cat harus menyediakan keduanya.

Untuk field age, salah satu cara sederhananya:

class Cat implements Animal {
  @override
  int age = 5;

  @override
  void sound() {
    print("Meow");
  }
}

7. Getter dan Setter Juga Termasuk Kontrak

Ini penting.

Misalnya:

class Person {
  String _name = "Unknown";

  String get name => _name;

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

Kemudian:

class Employee implements Person {
}

Belum lengkap.

Karena interface Person memiliki:

name getter
name setter

Jadi implementing class harus menyediakan getter dan setter yang sesuai.

Contoh:

class Employee implements Person {
  String _name = "";

  @override
  String get name => _name;

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

Jadi jangan berpikir interface hanya berisi method.

Interface dapat melibatkan:

• instance field/interface getter
• setter
• method
• property lainnya yang menjadi bagian dari interface

8. Static Member Tidak Perlu Diimplementasikan

Ini salah satu perbedaan penting.

Misalnya:

class Animal {
  static int count = 10;

  static void showCount() {
    print(count);
  }

  void sound() {
    print("Sound");
  }
}

Kemudian:

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

Tidak perlu:

static int count = ...

dan tidak perlu:

static void showCount() { ... }

Karena static member bukan bagian dari instance interface yang harus diimplementasikan oleh object.

Static member tetap milik class:

Animal.count;
Animal.showCount();

9. Kenapa Static Tidak Diimplementasikan?

Ingat materi static sebelumnya.

Static:

Animal.count

milik class.

Sedangkan implements berhubungan dengan bagaimana sebuah class memenuhi kontrak instance.

Gambaran sederhananya:

Animal
│
├── instance member
│     ├── sound()
│     └── age
│
└── static member
      ├── count
      └── showCount()

implements fokus pada bagian instance interface.

10. Constructor Tidak Berperan dalam implements

Ini juga sangat penting.

Misalnya:

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

  void sound() {
    print("Animal sound");
  }
}

Kemudian:

class Cat implements Animal {
  Cat() {
    print("Cat constructor");
  }

  @override
  void sound() {
    print("Meow");
  }
}

Ketika:

Cat();

output:

Cat constructor

Bukan:

Animal constructor
Cat constructor

Kenapa?

Karena:

implements Animal

bukan inheritance constructor.

Animal hanya digunakan sebagai interface/kontrak.

11. Bandingkan dengan extends

Kalau:

class Cat extends Animal {
  Cat() {
    print("Cat constructor");
  }
}

Maka constructor superclass dapat terlibat dalam proses konstruksi.

Secara sederhana:

Cat()
 ↓
Animal constructor
 ↓
Cat constructor

Sedangkan:

class Cat implements Animal

tidak membuat constructor Animal menjadi bagian dari construction process Cat.

Ini perbedaan yang sangat penting:

12. Kenapa super Tidak Bisa Digunakan untuk Interface?

Misalnya:

class Animal {
  void sound() {
    print("Animal sound");
  }
}

Kemudian:

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

Tidak boleh.

Kenapa?

Karena Animal bukan superclass dari Cat.

Hubungannya adalah:

Cat implements Animal

bukan:

Cat extends Animal

Jadi super tidak bisa digunakan untuk mengakses implementation dari Animal.

13. Kalau Menggunakan extends

Ini valid:

class Cat extends Animal {
  @override
  void sound() {
    super.sound();

    print("Meow");
  }
}

Output:

Animal sound
Meow

Karena Animal benar-benar superclass dari Cat.

14. Implicit Interface

Sekarang masuk ke istilah:

implicit interface

Karena Dart tidak memiliki keyword interface, setiap class secara otomatis menyediakan interface berdasarkan public API instance-nya.

Misalnya:

class Animal {
  void sound() {
    print("Sound");
  }

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

Class ini otomatis dapat digunakan sebagai interface:

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

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

Kita tidak perlu mendeklarasikan:

interface Animal

Itulah sebabnya disebut implicit interface.

15. Apakah Dart Memiliki Explicit Interface?

Untuk Dart modern, tidak ada deklarasi explicit interface khusus seperti Java.

Namun kita dapat menggunakan abstract class untuk mendapatkan desain yang mirip dengan explicit interface.

Misalnya:

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

Kemudian:

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

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

Ini terlihat seperti interface.

Tetapi secara teknis:

Animal = abstract class

bukan sebuah konstruksi:

interface Animal

seperti pada Java.

16. Kenapa Abstract Class Cocok untuk “Interface-like Design”?

Karena kita bisa membuat:

abstract class Payment {
  void pay();
  void refund();
}

Class ini tidak menyediakan implementasi.

Dia hanya menetapkan kontrak:

Payment
├── pay()
└── refund()

Kemudian:

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

  @override
  void refund() {
    print("Refund to credit card");
  }
}

Ini sangat mirip dengan konsep interface di Java.

17. Interface Bisa Lebih dari Satu

Nah, ini salah satu kelebihan besar implements.

Dart hanya mengizinkan satu superclass langsung dengan extends.

Misalnya:

class A {}
class B {}

class C extends A, B {} // ERROR

Tidak boleh.

Tetapi kita bisa:

class C implements A, B {
}

Artinya C memenuhi kontrak dari A dan B.

18. Contoh Multiple Interface

Misalnya:

abstract class Area {
  double area();
}

abstract class Perimeter {
  double perimeter();
}

Kemudian:

class Rectangle implements Area, Perimeter {
  double width;
  double height;

  Rectangle(this.width, this.height);

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

  @override
  double perimeter() {
    return 2 * (width + height);
  }
}

Penggunaan:

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

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

Output:

200
60

19. Kenapa Multiple Interface Berguna?

Bayangkan sebuah object memiliki beberapa kemampuan.

Misalnya:

SmartPhone
├── Camera
├── MusicPlayer
└── GPS

Kita bisa memiliki kontrak:

abstract class Camera {
  void takePhoto();
}

abstract class MusicPlayer {
  void playMusic();
}

abstract class GPS {
  void getLocation();
}

Kemudian:

class SmartPhone implements Camera, MusicPlayer, GPS {
  @override
  void takePhoto() {
    print("Taking photo");
  }

  @override
  void playMusic() {
    print("Playing music");
  }

  @override
  void getLocation() {
    print("Getting location");
  }
}

Jadi satu class bisa memenuhi beberapa kontrak.

20. extends + implements Bisa Digabung

Ini juga bisa:

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

abstract class Flyable {
  void fly();
}

abstract class Swimmable {
  void swim();
}

Kemudian:

class Duck extends Animal implements Flyable, Swimmable {
  @override
  void fly() {
    print("Duck flying");
  }

  @override
  void swim() {
    print("Duck swimming");
  }
}

Artinya:

Duck
 │
 ├── extends Animal
 │      ↓
 │   inheritance
 │
 ├── implements Flyable
 │      ↓
 │   contract
 │
 └── implements Swimmable
        ↓
     contract

Ini pola yang sangat penting di Dart.

21. Abstract Class Bisa Menjadi Interface

Misalnya:

abstract class Animal {
  void sound();

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

Bisa:

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

atau:

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

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

Perhatikan perbedaannya.

extends

Cat mendapatkan:

eat()

dari Animal.

implements

Dog harus membuat sendiri:

sound()
eat()

Walaupun eat() sudah punya body di Animal.

Ini salah satu contoh paling bagus untuk membedakan extends dan implements.

22. Interface Bisa Berasal dari Concrete Class

Tidak harus abstract.

Misalnya:

class Animal {
  void sound() {
    print("Sound");
  }
}

Tetap bisa:

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

Jadi:

Concrete class
       ↓
bisa menjadi interface

Abstract class
       ↓
juga bisa menjadi interface

23. Interface Tidak Sama dengan Abstract Class

Ini penting supaya tidak tertukar.

Abstract class

abstract class Animal {
  void sound();

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

Animal adalah abstract class.

Ketika digunakan dengan implements

class Cat implements Animal {
  ...
}

Dalam konteks hubungan tersebut, Animal digunakan sebagai interface.

Jadi satu class dapat dipandang berbeda tergantung bagaimana kita menggunakannya.

24. Abstract Class vs Interface

Perbandingan sederhana:

25. Abstract Class + extends

Contoh:

abstract class Animal {
  void sound();

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

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

Cat mendapatkan:

sound() → wajib dibuat
eat()   → diwariskan

26. Abstract Class + implements

abstract class Animal {
  void sound();

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

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

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

Cat harus membuat:

sound() → wajib
eat()   → juga wajib

Karena implements mengambil interface, bukan implementation.

27. Abstract Class Bisa Extend Class

Transcript juga membahas bahwa interface dapat memiliki hierarchy.

Contohnya:

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

abstract class FlyingAnimal extends Animal {
  void fly();
}

Kemudian:

class Bird extends FlyingAnimal {
  @override
  void fly() {
    print("Flying");
  }
}

FlyingAnimal:

• merupakan abstract class
• extends Animal
• memiliki abstract method fly()

28. Interface Bisa Memperluas Interface Lain

Misalnya:

abstract class Animal {
  void eat();
}

abstract class FlyingAnimal implements Animal {
  void fly();

  @override
  void eat();
}

Kemudian:

class Bird implements FlyingAnimal {
  @override
  void eat() {
    print("Bird eating");
  }

  @override
  void fly() {
    print("Bird flying");
  }
}

Jadi kontrak dapat dibangun secara bertingkat.

29. Abstract Subclass Bisa Menunda Implementasi

Misalnya:

abstract class Animal {
  void sound();
}

Kemudian:

abstract class Cat extends Animal {
}

Ini valid karena Cat juga abstract.

Kemudian:

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

Jadi implementasi dapat ditunda:

Animal
abstract
   ↓
Cat
abstract
   ↓
PersianCat
concrete

30. Kenapa Abstract Class yang Mengimplementasikan Interface Tidak Error?

Misalnya:

class Animal {
  void sound() {
    print("Sound");
  }
}

abstract class Cat implements Animal {
}

Cat tidak memberikan sound().

Tapi tidak masalah karena Cat sendiri abstract.

Dari sudut pandang desain:

“Saya belum mau memberikan implementasi final. Nanti subclass saya yang menyelesaikannya.”

31. Praktical Use Interface #1 — Memaksa Override

Misalnya kita punya:

class Logger {
  void log() {
    print("Default log");
  }
}

Kalau:

class FileLogger extends Logger {
}

maka FileLogger mendapatkan log().

Tetapi misalnya kita ingin setiap logger memiliki implementasi log() sendiri.

Kita dapat menggunakan:

class FileLogger implements Logger {
  @override
  void log() {
    print("Logging to file");
  }
}

Sekarang FileLogger harus menyediakan implementasinya.

Ini berguna ketika kita ingin membuat kontrak implementasi tanpa mewariskan body method.

32. Practical Use #2 — Multiple Contracts

Ini adalah salah satu penggunaan interface yang sangat kuat.

Misalnya:

abstract class Printable {
  void printData();
}

abstract class Savable {
  void save();
}

Kemudian:

class Report implements Printable, Savable {
  @override
  void printData() {
    print("Printing report");
  }

  @override
  void save() {
    print("Saving report");
  }
}

Report sekarang memiliki dua tanggung jawab:

Printable
   ↓
printData()

Savable
   ↓
save()

        ↓

      Report

Kalau kita menggunakan inheritance biasa, kita tidak bisa:

class Report extends Printable, Savable

karena Dart tidak mendukung multiple superclass.

33. Interface Sangat Cocok untuk Polymorphism

Misalnya:

abstract class Payment {
  void pay();
}

Kemudian:

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

dan:

class CashPayment implements Payment {
  @override
  void pay() {
    print("Pay with cash");
  }
}

Kita dapat membuat:

void processPayment(Payment payment) {
  payment.pay();
}

Kemudian:

processPayment(CreditCardPayment());
processPayment(CashPayment());

Output:

Pay with credit card
Pay with cash

Ini adalah kombinasi:

Interface
   +
Implementation
   +
Overriding
   +
Polymorphism

34. Contoh yang Lebih Nyata: Repository

Misalnya dalam aplikasi Flutter kita ingin mengambil data user.

Kita bisa menentukan kontrak:

abstract class UserRepository {
  Future<String> getUser();
}

Kemudian implementasi pertama:

class ApiUserRepository implements UserRepository {
  @override
  Future<String> getUser() async {
    return "User from API";
  }
}

Implementasi kedua:

class LocalUserRepository implements UserRepository {
  @override
  Future<String> getUser() async {
    return "User from local database";
  }
}

Kemudian kode aplikasi cukup bergantung pada:

UserRepository

bukan pada:

ApiUserRepository

atau:

LocalUserRepository

Ini sangat berguna untuk membuat aplikasi yang lebih mudah diubah dan dites.

35. Interface dalam Arsitektur Flutter

Misalnya:

UI
 ↓
UserRepository
 ↓
ApiUserRepository

UI tidak perlu tahu detail bagaimana API bekerja.

UI hanya tahu:

abstract class UserRepository {
  Future<String> getUser();
}

Kemudian implementasinya bisa berubah:

UserRepository
      |
      ├── ApiUserRepository
      |
      ├── LocalUserRepository
      |
      └── MockUserRepository

MockUserRepository misalnya sangat berguna untuk testing.

Inilah salah satu alasan interface sangat penting dalam software engineering.

36. Kesalahan Pemahaman yang Sering Terjadi

Ada beberapa hal dari transcript yang perlu diluruskan.

❌ “Interface hanya bisa berasal dari abstract class”

Tidak.

Class biasa juga dapat digunakan sebagai interface:

class A {}
class B implements A {}

❌ “Dart memiliki explicit interface”

Dart tidak memiliki keyword interface khusus seperti Java.

Yang ada adalah class yang secara otomatis memiliki interface.

❌ “Implements hanya mengambil abstract method”

Tidak.

Dengan implements, class harus memenuhi interface instance member, termasuk member yang concrete pada class sumber.

Contoh:

class A {
  void test() {}
}

Kalau:

class B implements A

B tetap harus menyediakan test().

❌ “Constructor interface dipanggil”

Tidak.

implements

tidak membuat constructor dari interface menjadi bagian dari constructor subclass.

❌ “Static member harus diimplementasikan”

Tidak.

Static member bukan instance member yang harus diimplementasikan.

37. @override Sangat Dianjurkan

Ketika mengimplementasikan interface:

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

@override membantu:

• menunjukkan bahwa member tersebut berasal dari superclass/interface
• membuat kode lebih mudah dibaca
• membantu analyzer mendeteksi kesalahan

Jadi biasakan:

@override

ketika melakukan override/implementasi member yang diwariskan atau menjadi bagian interface.

38. Ringkasan extends vs implements

Ini tabel yang paling penting dari seluruh materi:

39. Cara Mengingat extends dan implements

Gunakan dua kata ini:

extends = WARISI

class Cat extends Animal

Artinya:

“Cat mewarisi sesuatu dari Animal.”

implements = PATUHI

class Cat implements Animal

Artinya:

“Cat harus memenuhi kontrak/interface Animal.”

Jadi:

extends
↓
"Berikan saya yang sudah kamu punya."

implements
↓
"Saya berjanji akan menyediakan semua yang kamu minta."

40. Hubungkan dengan Materi Abstract Class Sebelumnya

Sebelumnya kita belajar:

abstract class Shape {
  double area();
}

Kemudian:

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

Sekarang kita bisa:

abstract class Area {
  double area();
}

Kemudian:

class Rectangle implements Area {
  @override
  double area() {
    return 100;
  }
}

Keduanya sama-sama bisa membuat kontrak, tetapi mekanismenya berbeda.

extends

Shape
 ↓
Rectangle

Rectangle adalah subclass Shape dan dapat mewarisi implementation.

implements

Area
 ↓
Rectangle

Rectangle mengikuti interface Area dan harus menyediakan implementation sendiri.

41. Hubungkan dengan Polymorphism

Misalnya:

abstract class Shape {
  double area();
}

class Rectangle implements Shape {
  @override
  double area() {
    return 100;
  }
}

class Circle implements Shape {
  @override
  double area() {
    return 50;
  }
}

Kemudian:

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

Kita bisa:

printArea(Rectangle());
printArea(Circle());

Output:

100
50

printArea() tidak perlu tahu:

“Apakah ini Rectangle?”

atau:

“Apakah ini Circle?”

Dia hanya tahu:

“Object ini memenuhi kontrak Shape.”

Ini adalah salah satu kekuatan interface.

42. Gambaran Besar Konsepnya

Coba simpan diagram mental ini:

                     INTERFACE
                         │
                  "Kontrak/aturan"
                         │
            ┌────────────┼────────────┐
            ↓            ↓            ↓
        Rectangle      Circle       Triangle
            │            │            │
          area()       area()        area()
            │            │            │
       implementasi  implementasi  implementasi
       masing-masing masing-masing masing-masing

Interface mengatakan:

"Kalian semua harus punya area()."

Tetapi:

Rectangle → cara A
Circle    → cara B
Triangle  → cara C

43. Inti Materi yang Harus Kamu Kuasai

Kalau setelah menonton video ini kamu hanya mengingat 8 hal, pastikan ini:

1. Dart tidak punya keyword interface khusus

Class secara otomatis dapat bertindak sebagai interface.

2. implements menggunakan class sebagai kontrak

class B implements A

3. extends berbeda dengan implements

extends
→ inheritance + implementation

implements
→ contract/interface

4. implements tidak mewarisi body method

Semua instance member interface harus dipenuhi oleh implementing class.

5. Constructor tidak diwariskan melalui implements

Constructor interface tidak dipanggil ketika membuat object implementing class.

6. Static member tidak perlu diimplementasikan

Karena static member adalah milik class, bukan instance.

7. Bisa mengimplementasikan banyak interface

class C implements A, B, D {
}

8. Interface sangat berguna untuk abstraction dan polymorphism

Kode kita dapat bergantung pada kontrak, bukan implementasi konkret.

🧠 Satu analogi terakhir

Bayangkan ada sertifikasi pekerjaan.

Sertifikasi mengatakan:

Seorang DRIVER harus bisa:
- drive()
- brake()
- park()

Dalam Dart:

abstract class Driver {
  void drive();
  void brake();
  void park();
}

Kemudian:

class TaxiDriver implements Driver {
  @override
  void drive() {
    print("Taxi driving");
  }

  @override
  void brake() {
    print("Taxi braking");
  }

  @override
  void park() {
    print("Taxi parking");
  }
}

Driver tidak mengatakan bagaimana TaxiDriver harus melakukan semuanya.

Dia hanya mengatakan:

“Kalau kamu mengaku sebagai Driver, kamu harus menyediakan kemampuan ini.”

Itulah interface.

Dan perbedaan paling fundamental yang perlu kamu pegang adalah:

                extends
                  ↓
          "Saya mewarisi"
                  │
                  │
          implementation
                  │
                  ↓
              Parent


              implements
                  ↓
          "Saya mematuhi"
                  │
                  │
               contract
                  │
                  ↓
              Interface

Jadi kalau nanti kamu melihat kode Flutter seperti:

class MyClass implements SomeClass {
  @override
  ...
}

langsung pikir:

“Oh, SomeClass sedang dipakai sebagai kontrak/interface, bukan sebagai sumber implementation yang diwariskan.”

Sedangkan kalau melihat:

class MyClass extends SomeClass {
  @override
  ...
}

pikir:

"SomeClass adalah superclass; MyClass mewarisi dan bisa mengubah behavior-nya melalui overriding."