Progres sesi
0 / 4
Sheet 04 · Materi Detail

Sifat Turunan

Sama seperti resep turunan yang mewarisi langkah-langkah resep dasarnya, sebuah class juga bisa mewarisi properti dan method dari class lain dengan extends.

Durasi: 120 menit Prasyarat: encapsulation (Pertemuan 3) Bahasa: JavaScript (ES6+)
1

Masalah: Resep yang Ditulis Ulang

Coba bayangin dua resep kue yang mirip banget: sama-sama harus ngocok telur, sama-sama dipanggang di suhu yang sama — tapi masing-masing ditulis dari nol di kertas terpisah, kayak nggak ada hubungannya, padahal sebenarnya keduanya itu "anak" dari resep dasar yang sama.

Nah, hal yang mirip kejadian kalau Kucing dan Anjing kita tulis sebagai dua class yang benar-benar terpisah, padahal keduanya kan sama-sama Hewan yang punya nama dan bisa makan.

tanpa-warisan.js
class KucingDuplikat {
  constructor(nama) {
    this.nama = nama;
  }
  makan() {
    console.log(`${this.nama} sedang makan`);
  }
  mengeong() {
    console.log(`${this.nama} bilang: Meong!`);
  }
}

class AnjingDuplikat {
  constructor(nama) {
    this.nama = nama;
  }
  makan() {
    console.log(`${this.nama} sedang makan`); // identik dengan KucingDuplikat!
  }
  menggonggong() {
    console.log(`${this.nama} bilang: Guk guk!`);
  }
}

const kitty = new KucingDuplikat("Milo");
const rex = new AnjingDuplikat("Rex");
kitty.makan();
rex.makan();
Klik "Jalankan" untuk melihat hasilnya.
Coba perhatiin: constructor sama method makan() di dua class itu persis sama, kan? Ini duplikasi yang sama kayak yang kita bahas di Pertemuan 2 — bedanya sekarang kejadiannya antar-class, bukan antar-objek.
2

extends & super(): Resep Turunan

Solusinya gampang: bikin satu "resep dasar" — class Hewan — yang nyimpen hal-hal yang dipunyai semua hewan (nama, bisa makan). Terus Kucing dan Anjing tinggal mewarisinya pakai extends, dan cukup nambahin hal yang bener-bener khas punya mereka masing-masing.

dengan-warisan.js
class Hewan {
  constructor(nama) {
    this.nama = nama;
  }
  makan() {
    console.log(`${this.nama} sedang makan`);
  }
}

// Kucing tidak menambah properti baru, jadi tidak perlu constructor sendiri —
// JavaScript otomatis mewariskan constructor milik Hewan.
class Kucing extends Hewan {
  mengeong() {
    console.log(`${this.nama} bilang: Meong!`);
  }
}

// Anjing menambah properti baru (umur), jadi butuh constructor sendiri,
// dan WAJIB memanggil super(nama) dulu sebelum memakai "this".
class Anjing extends Hewan {
  constructor(nama, umur) {
    super(nama);
    this.umur = umur;
  }
  menggonggong() {
    console.log(`${this.nama} (${this.umur} tahun) bilang: Guk guk!`);
  }
}

const kitty = new Kucing("Milo");
const rex = new Anjing("Rex", 3);

kitty.makan();       // diwarisi dari Hewan
kitty.mengeong();     // milik Kucing sendiri
rex.makan();          // diwarisi dari Hewan
rex.menggonggong();   // milik Anjing sendiri
Klik "Jalankan" untuk melihat hasilnya.
Catatan penting: super(nama) itu manggil constructor punya Hewan buat ngisi this.nama. Sebelum baris itu dipanggil, this belum boleh dipakai sama sekali di constructor anak — inget-inget ya.
3

is-a vs has-a

Kucing extends Hewan artinya "Kucing itu adalah (is-a) Hewan". Tapi nggak semua hubungan antar class kayak gitu lho — kadang satu class cuma "punya (has-a)" objek lain, tanpa perlu mewarisinya sama sekali.

komposisi-has-a.js
class Mesin {
  nyalakan() {
    console.log("Mesin menyala... vroom!");
  }
}

class Mobil {
  constructor(merek) {
    this.merek = merek;
    this.mesin = new Mesin(); // Mobil "punya" Mesin, bukan "adalah" Mesin
  }
  jalankan() {
    this.mesin.nyalakan();
    console.log(`${this.merek} mulai berjalan`);
  }
}

const avanza = new Mobil("Avanza");
avanza.jalankan();
Klik "Jalankan" untuk melihat hasilnya.
Gampangnya gini: kalau kalimatnya masuk akal diucapin sebagai "X adalah Y" → pakai extends (is-a). Kalau lebih pas jadi "X punya Y" → simpen aja sebagai properti biasa (has-a), kayak Mobil yang nyimpen Mesin.
4

Latihan: Keluarga Besar Kendaraan

Yuk lengkapi Mobil dan Motor di bawah ini biar keduanya mewarisi Kendaraan lewat extends, panggil super(...) buat ngisi data yang diwarisi, terus simpan properti tambahan yang khas punya masing-masing.

latihan-kendaraan.js — bisa diedit
Lengkapi kode lalu klik "Jalankan".
kunci-jawaban.js
class Mobil extends Kendaraan {
  constructor(merek, kecepatanMaks, jumlahPintu) {
    super(merek, kecepatanMaks);
    this.jumlahPintu = jumlahPintu;
  }
}

class Motor extends Kendaraan {
  constructor(merek, kecepatanMaks, tipe) {
    super(merek, kecepatanMaks);
    this.tipe = tipe;
  }
}
5

Cek Pemahaman

1. Sebenarnya, extends itu ngapain sih ke sebuah class?

Persis kayak resep turunan yang mewarisi langkah-langkah resep dasarnya.

2. Kenapa sih super(nama) harus dipanggil dulu sebelum kita pakai this di constructor anak?

Tanpa manggil super() duluan, this di constructor anak belum terbentuk sepenuhnya.

3. Nah, bedanya is-a sama has-a itu apa sih?

Coba tes pakai kalimat: "Kucing adalah Hewan" masuk akal kan (is-a), tapi "Mobil adalah Mesin" janggal (harusnya has-a).

4. Kenapa ya class Kucing di contoh tadi nggak perlu nulis constructor sendiri?

Kalau class anak nggak nambah data baru, JavaScript otomatis "mewariskan" constructor punya induknya.
Skor: 0 / 4 terjawab benar
6

Ringkasan Pertemuan 4

  • extends bikin class anak mewarisi properti dan method dari class induk — jadi nggak perlu duplikasi kode antar-class yang mirip.
  • super(...) manggil constructor induk buat ngisi data yang diwarisi; wajib dipanggil sebelum this dipakai di constructor anak.
  • Kalau class anak nggak nambah data baru, constructor sendiri boleh nggak usah ditulis sama sekali.
  • is-a (pewarisan lewat extends) itu beda sama has-a (punya objek lain sebagai properti biasa).
Selanjutnya

Di Pertemuan 5 kita bakal lihat gimana class anak bisa mengubah (override) method yang diwariskan, bukan cuma pakai apa adanya.

made by boflyeta.dev