Coba bayangkan aba-aba "mulai!" di balapan: mobil melaju, motor menyalip, dan sepeda mulai mengayuh. Satu perintah, tetapi responsnya berbeda-beda.
Masih inget Lingkaran dan PersegiPanjang dari Pertemuan 5? Keduanya sama-sama punya method luas(), meski rumusnya beda total. Nah sekarang coba lihat apa yang terjadi kalau keduanya dikumpulin dalam satu daftar, terus dipanggil .luas() secara seragam — tanpa kode pemanggilnya tahu bentuk spesifik yang mana.
class Bentuk {
constructor(nama) { this.nama = nama; }
luas() { return 0; }
}
class Lingkaran extends Bentuk {
constructor(jariJari) { super("Lingkaran"); this.jariJari = jariJari; }
luas() { return Math.PI * this.jariJari ** 2; }
}
class PersegiPanjang extends Bentuk {
constructor(panjang, lebar) { super("Persegi Panjang"); this.panjang = panjang; this.lebar = lebar; }
luas() { return this.panjang * this.lebar; }
}
class Segitiga extends Bentuk {
constructor(alas, tinggi) { super("Segitiga"); this.alas = alas; this.tinggi = tinggi; }
luas() { return 0.5 * this.alas * this.tinggi; }
}
const daftarBentuk = [
new Lingkaran(7),
new PersegiPanjang(5, 3),
new Segitiga(6, 4)
];
// satu perintah yang sama, .luas(), dipanggil ke semua bentuk berbeda
daftarBentuk.forEach(b => {
console.log(`${b.nama}: luas = ${b.luas().toFixed(2)}`);
});
b.luas() ditulis sekali doang, tapi hasilnya beda-beda tergantung objek mana yang lagi dipanggil — masing-masing merespons dengan caranya sendiri.Coba bayangin aba-aba "MULAI!" di garis start balapan. Semua peserta dengar perintah yang sama persis, tapi Mobil melaju di jalan raya, Motor menyalip di celah sempit, Sepeda mulai mengayuh pelan-pelan. Satu aba-aba, gerakannya macam-macam — itulah polymorphism dalam bentuk yang paling literal.
class Kendaraan {
constructor(nama) { this.nama = nama; }
mulai() {
console.log(`${this.nama} bersiap...`);
}
}
class Mobil extends Kendaraan {
mulai() {
console.log(`${this.nama} melaju kencang di jalan raya!`);
}
}
class Motor extends Kendaraan {
mulai() {
console.log(`${this.nama} menyalip lincah di celah kemacetan!`);
}
}
class Sepeda extends Kendaraan {
mulai() {
console.log(`${this.nama} mulai mengayuh pelan-pelan.`);
}
}
const pesertaBalapan = [
new Mobil("Mobil Nomor 1"),
new Motor("Motor Nomor 2"),
new Sepeda("Sepeda Nomor 3")
];
console.log("=== ABA-ABA: MULAI! ===");
pesertaBalapan.forEach(k => k.mulai());
Di JavaScript, polymorphism bahkan nggak selalu butuh hubungan extends lho. Kalau dua objek sama-sama punya method dengan nama yang sama, keduanya bisa dipanggil secara seragam — biarpun class-nya sama sekali nggak berhubungan.
class Robot {
bicara() {
console.log("BEEP BOOP, saya robot.");
}
}
class Manusia {
bicara() {
console.log("Halo, saya manusia.");
}
}
const pembicara = [new Robot(), new Manusia()];
pembicara.forEach(p => p.bicara());
// Robot dan Manusia TIDAK punya hubungan inheritance apa pun,
// tapi keduanya punya method bicara() -> tetap bisa dipanggil seragam.
// Ini disebut "duck typing": kalau jalannya seperti bebek dan
// bersuara seperti bebek, JavaScript menganggapnya bebek.
Override hitungGaji() di Manajer (gaji pokok + tunjangan) dan Magang (setengah dari gaji pokok). Kode di bawah udah bisa menghitung total gaji dari array campuran, tanpa perlu tahu jenis karyawan yang mana — nah, itulah polymorphism lagi bekerja.
class Manajer extends Karyawan {
constructor(nama, gajiPokok, tunjangan) {
super(nama, gajiPokok);
this.tunjangan = tunjangan;
}
hitungGaji() {
return this.gajiPokok + this.tunjangan;
}
}
class Magang extends Karyawan {
constructor(nama, uangSaku) {
super(nama, uangSaku);
}
hitungGaji() {
return this.gajiPokok * 0.5;
}
}
1. Sebenarnya polymorphism itu apa sih?
2. Di daftarBentuk.forEach(b => b.luas()), kenapa kode ini nggak perlu tahu apakah b itu Lingkaran atau PersegiPanjang?
3. "Duck typing" di JavaScript itu apaan sih?
4. Di latihan Payroll, kenapa hitungGaji() perlu di-override di Manajer dan Magang?
forEach) nggak perlu tahu tipe spesifik tiap objek — cukup percaya method yang tepat bakal jalan.