Progres sesi
0 / 4
Sheet 09 · Materi Detail

Pabrik dan Kantor Pusat

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.

Durasi: 120 menit Prasyarat: static member (Pertemuan 8) Bahasa: JavaScript (ES6+)
1

Factory Pattern: Pabrik Pesanan

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.

bentuk-factory.js
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());
Klik "Jalankan" untuk melihat hasilnya.
Perhatiin nih: buat() itu static — persis konsep yang kita bahas di Pertemuan 8. Dipanggilnya lewat BentukFactory.buat(...), bukan dari instance bentuk yang belum tentu ada.
2

Singleton Pattern: Kantor Pusat Tunggal

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.

logger-singleton.js
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);
Klik "Jalankan" untuk melihat hasilnya.
Perhatiin nih: walaupun kita nulis 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.
3

Kapan Memakai Pattern Ini?

  • Factory cocok dipakai kalau logika "class mana yang harus dibuat" itu cukup ribet atau sering berubah-ubah — dengan factory, logikanya jadi terpusat di satu tempat, nggak tersebar di banyak baris new.
  • Singleton cocok buat hal-hal yang emang dari sananya harus tunggal di seluruh aplikasi — kayak logger, koneksi konfigurasi, atau cache global.
  • Design pattern itu bukan aturan wajib yang harus dipakai di mana-mana. Pakai kalau emang beneran nyelesain masalah nyata, bukan cuma "biar keliatan rapi".
4

Latihan: Factory Notifikasi

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.

latihan-notifikasi-factory.js — bisa diedit
Lengkapi kode lalu klik "Jalankan".
kunci-jawaban.js
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`);
    }
  }
}
5

Cek Pemahaman

1. Sebenernya, masalah apa sih yang diselesaikan sama Factory pattern?

Sama kayak bagian pemesanan pabrik — kamu tinggal sebutin "tipe"-nya, nggak perlu tahu lini produksinya.

2. Apa sih ciri khas dari Singleton pattern?

Ibarat kantor pusat — mau berapa pun cabang yang nelepon, tujuannya tetap kantor yang sama.

3. Di BentukFactory.buat("lingkaran", 7), kenapa sih method buat dibikin static?

Inget Pertemuan 8: static itu dipanggil lewat nama class, cocok buat method yang tugasnya "bikinin" objek.

4. Gimana caranya constructor Logger mastiin cuma ada satu instance?

Constructor itu ternyata boleh secara eksplisit ngembaliin objek lain — nah, di situ triknya.
Skor: 0 / 4 terjawab benar
6

Ringkasan Pertemuan 9

  • Factory pattern nyembunyiin logika "class mana yang harus dibuat" di satu tempat, biasanya lewat static method.
  • Singleton pattern mastiin cuma ada SATU instance dari suatu class di seluruh aplikasi, sering dipakai buat hal-hal kayak logger atau konfigurasi global.
  • Dua-duanya sebenernya cuma manfaatin konsep yang udah kita pelajari sebelumnya: static (Pertemuan 8) sama constructor (Pertemuan 2).
  • Design pattern itu bukan aturan wajib — pakai kalau emang beneran nyelesain masalah nyata, bukan cuma "biar keliatan keren".
Selanjutnya — Modul 4

Modul 3 selesai! Pertemuan 10 memulai Proyek Akhir, dimulai dari merancang struktur class untuk proyek pilihanmu sendiri.

made by boflyeta.dev