Sama seperti resep turunan yang mewarisi langkah-langkah resep dasarnya, sebuah class juga bisa mewarisi properti dan method dari class lain dengan extends.
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.
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();
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.extends & super(): Resep TurunanSolusinya 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.
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
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.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.
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();
extends (is-a). Kalau lebih pas jadi "X punya Y" → simpen aja sebagai properti biasa (has-a), kayak Mobil yang nyimpen Mesin.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.
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;
}
}
1. Sebenarnya, extends itu ngapain sih ke sebuah class?
2. Kenapa sih super(nama) harus dipanggil dulu sebelum kita pakai this di constructor anak?
3. Nah, bedanya is-a sama has-a itu apa sih?
4. Kenapa ya class Kucing di contoh tadi nggak perlu nulis constructor sendiri?
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.extends) itu beda sama has-a (punya objek lain sebagai properti biasa).