Materi kali ini membahas super keyword dalam Dart. Ini sangat penting karena super akan sering muncul ketika kamu belajar inheritance, constructor, method overriding, dan polymorphism.

Ada dua penggunaan utama super yang perlu kamu pahami dari materi ini:

1. super untuk mengakses property/method milik parent
2. super(...) untuk memanggil constructor parent

Mari kita bahas pelan-pelan.

1. Apa itu super?

Secara sederhana:

super digunakan untuk merujuk ke parent class.

Kalau:

class Laptop {
}

class MacBook extends Laptop {
}

maka:

Laptop
  ↑
  │
MacBook

Laptop adalah parent.

MacBook adalah child.

Dari dalam MacBook, keyword:

super

digunakan untuk mengatakan:

“Saya ingin mengakses bagian yang berasal dari parent saya.”

Jadi gampangnya:

this  → object/class yang sedang digunakan
super → parent class

2. this vs super

Ini sangat penting karena sebelumnya kita sudah belajar this.

this

this mengacu pada object saat ini.

super

super mengacu pada parent class.

Misalnya:

class Laptop {
  String name = "Laptop";
}

class MacBook extends Laptop {
  String name = "MacBook";

  void display() {
    print(this.name);
    print(super.name);
  }
}

Ketika:

MacBook mac = MacBook();
mac.display();

hasilnya:

MacBook
Laptop

Karena:

this.name

berarti:

Ambil name dari object/class MacBook saat ini.

Sedangkan:

super.name

berarti:

Ambil name dari parent, yaitu Laptop.

3. super pada Method

Ini adalah contoh pertama dari video.

Kita punya parent:

class Laptop {
  void show() {
    print("This is a Laptop");
  }
}

Kemudian child:

class MacBook extends Laptop {
  void show() {
    print("This is a MacBook");
  }
}

Perhatikan bahwa kedua class memiliki method dengan nama sama:

show()

Jadi:

Laptop
└── show()

MacBook
└── show()

4. Apa yang terjadi kalau kita panggil show()?

Kita buat object:

void main() {
  MacBook macBook = MacBook();

  macBook.show();
}

Output:

This is a MacBook

Kenapa bukan:

This is a Laptop

?

Karena MacBook memiliki method show() sendiri.

Dengan kata lain, MacBook meng-override method show() milik Laptop.

Konsep ini disebut:

Method Overriding

Kita akan mempelajarinya lebih dalam nanti.

5. Bagaimana Memanggil Method Parent?

Nah, di sinilah super digunakan.

Dari dalam MacBook, kita bisa menulis:

super.show();

Contohnya:

class Laptop {
  void show() {
    print("This is a Laptop");
  }
}

class MacBook extends Laptop {
  void show() {
    super.show();

    print("This is a MacBook");
  }
}

Kemudian:

void main() {
  MacBook macBook = MacBook();

  macBook.show();
}

Output:

This is a Laptop
This is a MacBook

Urutannya:

macBook.show()
      ↓
MacBook.show()
      ↓
super.show()
      ↓
Laptop.show()
      ↓
kembali ke MacBook.show()
      ↓
print("This is a MacBook")

6. Kenapa super.show() Berguna?

Bayangkan parent memiliki kemampuan umum:

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

Child ingin memiliki perilaku tambahan:

class Cat extends Animal {
  void eat() {
    super.eat();

    print("Cat is eating fish");
  }
}

Kemudian:

Cat cat = Cat();
cat.eat();

Output:

Animal is eating
Cat is eating fish

Jadi child bisa mengatakan:

“Jalankan dulu versi parent, kemudian saya tambahkan perilaku saya sendiri.”

Ini sangat berguna dalam inheritance.

7. super untuk Property/Variable

Sekarang bukan method, tetapi property.

Misalnya:

class Laptop {
  String name = "Laptop";
}

class MacBook extends Laptop {
  String name = "MacBook";

  void display() {
    print(name);
  }
}

Kalau:

MacBook macBook = MacBook();
macBook.display();

hasilnya:

MacBook

Karena:

name

di dalam MacBook mengarah ke property name milik MacBook.

8. Bagaimana Mengakses name milik Parent?

Gunakan:

super.name

Contoh:

class Laptop {
  String name = "Laptop";
}

class MacBook extends Laptop {
  String name = "MacBook";

  void display() {
    print(name);
    print(super.name);
  }
}

Kemudian:

void main() {
  MacBook macBook = MacBook();

  macBook.display();
}

Output:

MacBook
Laptop

Penjelasannya:

name

→ MacBook.name

Sedangkan:

super.name

→ Laptop.name

9. Gambaran Sederhananya

Bayangkan ada dua name:

        Laptop
        name = "Laptop"
           ↑
           │
        extends
           │
           ↓
        MacBook
        name = "MacBook"

Dari dalam MacBook:

name

artinya:

MacBook.name

Sedangkan:

super.name

artinya:

Laptop.name

10. Kenapa super Dibutuhkan?

Karena kadang parent dan child memiliki nama property atau method yang sama.

Contohnya:

class A {
  String name = "A";
}

class B extends A {
  String name = "B";
}

Sekarang di B terdapat dua property bernama name secara konseptual:

A → name
B → name

Kalau kita menulis:

name

yang digunakan adalah name milik B.

Kalau ingin secara eksplisit mengatakan:

“Saya mau yang dari parent.”

gunakan:

super.name

11. Penggunaan Kedua: super(...) pada Constructor

Ini penggunaan super yang sangat penting.

Sebelumnya kita sudah belajar constructor.

Misalnya parent:

class Laptop {
  String model;

  Laptop(this.model);
}

Parent membutuhkan:

model

ketika object dibuat.

Sekarang kita buat child:

class MacBook extends Laptop {
  String company;

  MacBook(this.company, String model);
}

Ini akan bermasalah karena constructor Laptop membutuhkan model.

Kita harus memberitahu:

“Nilai model ini kirim ke constructor parent.”

Caranya:

class MacBook extends Laptop {
  String company;

  MacBook(
    this.company,
    String model,
  ) : super(model);
}

Perhatikan:

: super(model)

12. Apa Arti super(model)?

Ini berarti:

Panggil constructor parent (Laptop) dan kirim model sebagai argument.

Strukturnya:

MacBook constructor
       │
       │ model
       ↓
super(model)
       │
       ↓
Laptop constructor
       │
       ↓
this.model = model

13. Contoh Lengkap

Parent:

class Laptop {
  String model;

  Laptop(this.model);
}

Child:

class MacBook extends Laptop {
  String company;

  MacBook(
    this.company,
    String model,
  ) : super(model);
}

Kemudian:

void main() {
  MacBook macBook = MacBook(
    "Apple",
    "MacBook Pro",
  );

  print(macBook.company);
  print(macBook.model);
}

Output:

Apple
MacBook Pro

Perhatikan:

MacBook
├── company → "Apple"
└── model   → "MacBook Pro"
                 ↑
              berasal dari
              Laptop

14. Kenapa Tidak Langsung this.model?

Karena model didefinisikan di parent:

class Laptop {
  String model;

  Laptop(this.model);
}

Sedangkan MacBook hanya memiliki:

String company;

Jadi constructor MacBook perlu meneruskan nilai model ke parent:

: super(model)

15. Mari Kita Bedah Kode Ini

Perhatikan:

class MacBook extends Laptop {
  String company;

  MacBook(
    this.company,
    String model,
  ) : super(model);
}

Kita pecah:

Bagian pertama

MacBook(...)

Ini adalah constructor MacBook.

this.company

this.company

berarti:

Parameter company langsung dimasukkan ke property company milik object MacBook.

Jadi:

MacBook("Apple", ...)

akan membuat:

company = "Apple"

String model

String model

adalah parameter constructor.

Nilai ini belum langsung dimasukkan ke field MacBook.

Nilai ini akan dikirim ke parent.

super(model)

: super(model)

berarti:

Kirim model ke constructor Laptop.

Sehingga:

Laptop(this.model);

menerima nilai tersebut.

16. Alur Saat Object Dibuat

Ketika kita menulis:

MacBook macBook = MacBook(
  "Apple",
  "MacBook Pro",
);

yang terjadi secara konsep:

                    MacBook(...)
                         │
             ┌───────────┴───────────┐
             ↓                       ↓
      company = Apple         model = MacBook Pro
                                     │
                                     ↓
                              super(model)
                                     │
                                     ↓
                            Laptop constructor
                                     │
                                     ↓
                            model = MacBook Pro

Jadi super(...) adalah jembatan untuk meneruskan argument ke constructor parent.

17. super.method() vs super(...)

Jangan sampai tertukar.

Ada dua bentuk yang kita pelajari:

A. super.method()

Digunakan untuk memanggil method parent.

super.show();

Artinya:

Jalankan show() milik parent.

B. super.property

Digunakan untuk mengakses property parent.

super.name

Artinya:

Ambil name milik parent.

C. super(...)

Digunakan untuk memanggil constructor parent.

super(model);

Artinya:

Panggil constructor parent dan kirim model.

18. Ringkasan Bentuk super

19. this dan super Berdampingan

Ini bagus untuk kamu hafalkan:

this
 ↓
object/class saat ini

super
 ↓
parent class

Contoh:

class Laptop {
  String name = "Laptop";
}

class MacBook extends Laptop {
  String name = "MacBook";

  void display() {
    print(this.name);
    print(super.name);
  }
}

Hasil:

MacBook
Laptop

Jadi:

this.name

→ punya MacBook.

super.name

→ punya Laptop.

20. Contoh Realistis

Misalnya:

            Vehicle
              │
              ↓
             Car

Parent:

class Vehicle {
  String brand;

  Vehicle(this.brand);

  void start() {
    print("Vehicle started");
  }
}

Child:

class Car extends Vehicle {
  int doors;

  Car(
    String brand,
    this.doors,
  ) : super(brand);

  void start() {
    super.start();
    print("Car engine started");
  }
}

Kemudian:

void main() {
  Car car = Car("Toyota", 4);

  print(car.brand);
  print(car.doors);

  car.start();
}

Output:

Toyota
4
Vehicle started
Car engine started

Di sini kita menggunakan dua bentuk super sekaligus:

super(brand)

untuk constructor parent.

Dan:

super.start()

untuk method parent.

21. Hubungan dengan Inheritance yang Sudah Dipelajari

Sebelumnya:

Inheritance
    ↓
extends
    ↓
Parent ← Child

Sekarang:

Inheritance
    ↓
extends
    ↓
Parent ← Child
          │
          ├── super.property
          ├── super.method()
          └── super(...)

Jadi super hanya masuk akal ketika kita berada dalam konteks subclass/child yang memiliki superclass/parent.

22. Hal Penting: super Bukan Membuat Object Baru

Ini kesalahan pemahaman yang sering terjadi.

Ketika kita menulis:

super.show();

kita tidak sedang membuat object baru dari parent.

Bukan:

buat Laptop baru

Tetapi lebih seperti:

“Jalankan implementasi show() yang berasal dari parent.”

Begitu juga:

super.name

bukan membuat object baru.

23. Hubungan dengan Method Overriding

Materi ini sebenarnya mulai mengarah ke method overriding.

Contoh:

class Laptop {
  void show() {
    print("Laptop");
  }
}

class MacBook extends Laptop {
  @override
  void show() {
    print("MacBook");
  }
}

MacBook menggantikan implementasi show() milik Laptop.

Karena itu:

MacBook mac = MacBook();
mac.show();

akan menjalankan:

MacBook

Tetapi kalau dari dalam method tersebut kita ingin menjalankan versi parent:

@override
void show() {
  super.show();
  print("MacBook");
}

maka:

Laptop
MacBook

@override sendiri akan kita bahas lebih mendalam nanti.

24. Kesalahan yang Sering Terjadi

❌ Salah memahami super

super();

Tidak berarti membuat object parent secara bebas.

Untuk constructor parent, super(...) digunakan pada initializer list constructor child, misalnya:

MacBook(String model) : super(model);

❌ Menggunakan super di luar child class

super digunakan dalam konteks subclass untuk mengakses superclass.

❌ Mengira super.name selalu diperlukan

Kalau tidak ada konflik nama dan kita memang ingin menggunakan member yang diwariskan, sering kali cukup:

name

Misalnya:

class Person {
  String name = "Budi";
}

class Student extends Person {
  void display() {
    print(name);
  }
}

Tetap bisa.

super.name berguna ketika kita ingin secara eksplisit menunjuk ke parent, terutama ketika child juga punya member dengan nama yang sama.

25. Gambaran Besar

Anggap saja:

              PARENT
             Laptop
                │
                │ extends
                ↓
              CHILD
             MacBook

Dari MacBook:

this
 │
 └──→ MacBook

super
 │
 └──→ Laptop

Maka:

this.name

→ name milik MacBook/current object.

super.name

→ name milik Laptop/parent.

super.show()

→ show() milik Laptop.

super(model)

→ constructor Laptop dengan argument model.

🧠 Cara Menghafalnya

Cukup ingat kalimat ini:

this = saya sendiri, super = orang tua saya.

Misalnya kamu adalah MacBook.

Saya = MacBook
Orang tua = Laptop

Jadi:

this.name

= nama saya.

super.name

= nama orang tua saya.

super.show()

= jalankan kemampuan orang tua saya.

super(model)

= kirim data ke constructor orang tua saya.

⭐ Kesimpulan

Ada 3 bentuk penting yang perlu kamu kuasai:

super.property

➡️ mengambil property dari parent.

super.method()

➡️ menjalankan method dari parent.

super(...)

➡️ memanggil constructor parent.

Dan hubungan paling penting:

this  → current class/object
super → parent class

Kalau kamu sudah benar-benar memahami extends + this + super, fondasi inheritance-mu sudah cukup kuat untuk masuk ke materi berikutnya seperti method overriding dan polymorphism.