Abstraction pada intinya adalah menyembunyikan detail yang rumit dan memastikan setiap class turunan tetap mematuhi "kontrak" yang harus dipenuhi.
Ingat di Pertemuan 5, Bentuk memiliki method luas() generik yang hanya mengembalikan 0. Jika class turunan lupa melakukan override pada luas(), program tidak akan error. Yang terjadi adalah ia memberikan hasil yang salah secara diam-diam. Kondisi ini jauh lebih berbahaya daripada error yang terlihat jelas, karena kita sering tidak menyadari bahwa ada sesuatu yang salah.
Coba bayangkan ada inspektur bangunan yang tidak pernah datang untuk mengecek pekerjaan. Jika kontraktor lupa memasang pintu darurat, tidak akan ada yang sadar sampai masalah terjadi dan sudah terlambat untuk diperbaiki.
Lupa nge-override luas() di sini nggak bikin error sama sekali — cuma ngasih jawaban yang diam-diam salah, dan itu yang bahaya.
class Bentuk {
constructor(nama) {
this.nama = nama;
}
luas() {
return 0; // default yang "aman" tapi menyesatkan
}
}
class BentukLupa extends Bentuk {
constructor() {
super("Lupa Override");
}
// sengaja tidak menulis luas() sendiri
}
const lupa = new BentukLupa();
console.log(`Luas ${lupa.nama}:`, lupa.luas()); // salah, tapi tidak ada yang tahu!
BentukAbstrak bakal langsung lempar error kalau (1) dia dibuat langsung, atau (2) luas()-nya dipanggil padahal belum di-override.
class BentukAbstrak {
constructor(nama) {
if (new.target === BentukAbstrak) {
throw new Error("BentukAbstrak tidak boleh dibuat langsung, cuma boleh diturunkan");
}
this.nama = nama;
}
luas() {
throw new Error(`luas() belum diimplementasikan di ${this.constructor.name}`);
}
}
class Lingkaran extends BentukAbstrak {
constructor(jariJari) {
super("Lingkaran");
this.jariJari = jariJari;
}
luas() {
return Math.PI * this.jariJari ** 2;
}
}
class BentukLupa extends BentukAbstrak {
constructor() {
super("Lupa Override");
}
// sengaja tidak menulis luas() sendiri
}
try {
new BentukAbstrak("Umum"); // dicegah!
} catch (e) {
console.log("Error 1:", e.message);
}
const bulat = new Lingkaran(7);
console.log("Lingkaran luas:", bulat.luas().toFixed(2));
const lupa = new BentukLupa();
try {
lupa.luas(); // ketahuan langsung, bukan diam-diam salah
} catch (e) {
console.log("Error 2:", e.message);
}
JavaScript itu sebenernya nggak punya keyword abstract bawaan kayak beberapa bahasa lain. Tapi tenang, pola yang sama bisa kok kita bikin sendiri pakai dua trik ini:
new.target — di dalam constructor, ini nunjukkin class mana yang beneran dipanggil pakai new. Kalau ternyata sama dengan class abstrak itu sendiri, berarti ada yang coba bikin langsung dari situ — makanya kita lempar error.throw secara default — method kayak luas() di class abstrak sengaja dibikin lempar error, biar setiap subclass kepaksa nge-override-nya dulu sebelum bisa dipakai dengan aman.Ada cara lain lagi buat bikin "kontrak" tanpa perlu extends sama sekali: tinggal cek aja apakah objeknya punya method yang dibutuhkan, sebelum kamu manggil method itu. Ini sebenernya perluasan dari duck typing yang udah kita kenalin di Pertemuan 6.
function bayarSemua(daftarPenerima) {
daftarPenerima.forEach(penerima => {
if (typeof penerima.bayar !== "function") {
console.log(`${penerima.nama ?? "Objek"} tidak punya method bayar() — dilewati`);
return;
}
penerima.bayar();
});
}
class KaryawanTetap {
constructor(nama, gaji) {
this.nama = nama;
this.gaji = gaji;
}
bayar() {
console.log(`Transfer gaji Rp${this.gaji.toLocaleString("id-ID")} ke ${this.nama}`);
}
}
class VendorEksternal {
constructor(nama, tagihan) {
this.nama = nama;
this.tagihan = tagihan;
}
bayar() {
console.log(`Bayar tagihan Rp${this.tagihan.toLocaleString("id-ID")} ke vendor ${this.nama}`);
}
}
class Magang { // sengaja TIDAK mengimplementasikan bayar()
constructor(nama) {
this.nama = nama;
}
}
const daftarPenerima = [
new KaryawanTetap("Sari", 5000000),
new VendorEksternal("PT Kertas Jaya", 2000000),
new Magang("Dian")
];
bayarSemua(daftarPenerima);
Coba lengkapi Karyawan dan Supplier di bawah ini supaya keduanya nepatin "kontrak" BisaDibayar — intinya masing-masing wajib punya method bayar(). Fungsi validasiBisaDibayar() bakal lempar error kalau kontraknya dilanggar.
class Karyawan {
constructor(nama, gaji) {
this.nama = nama;
this.gaji = gaji;
}
bayar() {
console.log(`Transfer gaji Rp${this.gaji.toLocaleString("id-ID")} ke ${this.nama}`);
}
}
class Supplier {
constructor(nama, tagihan) {
this.nama = nama;
this.tagihan = tagihan;
}
bayar() {
console.log(`Bayar tagihan Rp${this.tagihan.toLocaleString("id-ID")} ke ${this.nama}`);
}
}
1. Sebenernya, apa sih tujuan utama abstraction dalam OOP?
2. Ngapain sih kita ngecek new.target === BentukAbstrak di dalam constructor?
3. Kenapa luas() di BentukAbstrak sengaja langsung throw new Error(...), bukan return 0 aja?
4. Gimana caranya validasiBisaDibayar(objek) mastiin "kontrak" dipatuhi, padahal nggak ada interface formal ala TypeScript?
new.target, plus method yang wajib di-override bakal lempar error kalau versi bawaannya yang dipanggil.