Ini adalah dua pola desain yang paling sering ditemui: Factory yang merakit objek sesuai tipe yang diminta, dan Singleton yang memastikan hanya ada satu kantor pusat dalam aplikasi.
Coba bayangkan sebuah pabrik perakitan: Anda cukup memberi tahu bagian pemesanan, "Saya ingin lingkaran" atau "Saya ingin persegi panjang." Anda tidak perlu tahu lini produksi mana yang menangani pekerjaan tersebut, atau class apa yang harus dibuat dengan new. Biarkan bagian pemesanan (factory) yang menangani keputusan itu.
class Lingkaran {
constructor(jariJari) { this.jariJari = jariJari; }
luas() { return Math.PI * this.jariJari ** 2; }
}
class PersegiPanjang {
constructor(panjang, lebar) { this.panjang = panjang; this.lebar = lebar; }
luas() { return this.panjang * this.lebar; }
}
class Segitiga {
constructor(alas, tinggi) { this.alas = alas; this.tinggi = tinggi; }
luas() { return 0.5 * this.alas * this.tinggi; }
}
class BentukFactory {
static buat(tipe, ...ukuran) {
switch (tipe) {
case "lingkaran": return new Lingkaran(...ukuran);
case "persegiPanjang": return new PersegiPanjang(...ukuran);
case "segitiga": return new Segitiga(...ukuran);
default: throw new Error(`Tipe bentuk "${tipe}" tidak dikenal`);
}
}
}
// Pemanggil tidak perlu tahu class spesifiknya, cukup sebut "tipe"
const bentuk1 = BentukFactory.buat("lingkaran", 7);
const bentuk2 = BentukFactory.buat("persegiPanjang", 5, 3);
console.log("Luas bentuk 1:", bentuk1.luas().toFixed(2));
console.log("Luas bentuk 2:", bentuk2.luas());
buat() itu static — persis konsep yang kita bahas di Pertemuan 8. Dipanggilnya lewat BentukFactory.buat(...), bukan dari instance bentuk yang belum tentu ada.Sekarang coba bayangin kebalikannya: mau berapa pun cabang yang nelepon "kantor pusat", mereka semua bakal nyambung ke kantor yang sama persis — nggak pernah ada kantor pusat kedua yang dibangun. Nah, itulah Singleton: class yang jamin cuma ada SATU instance doang di seluruh aplikasi.
class Logger {
static #instance; // private static field menyimpan satu-satunya instance
constructor() {
if (Logger.#instance) {
return Logger.#instance; // sudah ada -> kembalikan yang lama, jangan buat baru
}
this.log = [];
Logger.#instance = this;
}
catat(pesan) {
this.log.push(pesan);
console.log(`[LOG] ${pesan}`);
}
}
const loggerA = new Logger();
const loggerB = new Logger();
loggerA.catat("Aplikasi dimulai");
loggerB.catat("User login");
console.log("Apakah loggerA dan loggerB objek yang sama persis?", loggerA === loggerB);
console.log("Isi log (dari loggerB):", loggerB.log);
new Logger() dua kali, loggerA === loggerB tetap bernilai true — keduanya emang objek yang sama persis, makanya catatan log dari loggerA juga ikut muncul di loggerB.new.Coba lengkapi NotifikasiFactory.buat() di bawah ini supaya balikin instance yang pas berdasarkan tipe: "email" → Email, "sms" → SMS, "push" → PushNotification. Jangan lupa lempar error kalau tipenya nggak dikenal.
class NotifikasiFactory {
static buat(tipe, tujuan, isi) {
switch (tipe) {
case "email": return new Email(tujuan, isi);
case "sms": return new SMS(tujuan, isi);
case "push": return new PushNotification(tujuan, isi);
default: throw new Error(`Tipe notifikasi "${tipe}" tidak dikenal`);
}
}
}
1. Sebenernya, masalah apa sih yang diselesaikan sama Factory pattern?
2. Apa sih ciri khas dari Singleton pattern?
3. Di BentukFactory.buat("lingkaran", 7), kenapa sih method buat dibikin static?
4. Gimana caranya constructor Logger mastiin cuma ada satu instance?
static (Pertemuan 8) sama constructor (Pertemuan 2).