Memahami Pola Desain The Gang of Four (GOF) Menggunakan Python
Pola desain Gang of Four (GOF) adalah serangkaian solusi untuk masalah desain perangkat lunak yang umum.
Berikut adalah penjelasan singkat untuk masing-masing dari 23 pola desain yang dijelaskan dalam buku “Design Patterns: Elements of Reusable Object-Oriented Software”.
- Abstract Factory: Menyediakan antarmuka untuk membuat keluarga objek terkait atau dependen tanpa menentukan class konkretnya.
- Builder: Memisahkan konstruksi objek dari [email protected], memungkinkan proses konstruksi yang sama untuk membuat representasi yang berbeda.
- Factory Method: Menentukan antarmuka untuk membuat objek, tetapi membiarkan subclass memutuskan class mana yang akan dibuat.
- Prototipe: Instance yang diinisialisasi sepenuhnya untuk disalin atau dikloning.
- Singleton: class yang hanya memiliki satu instance saja.
- Adaptor: Ubah antarmuka class menjadi antarmuka lain yang diharapkan klien.
- Bridge: Memisahkan abstraksi dari implementasinya sehingga keduanya dapat berbeda secara independen.
- Komposit: Menyusun objek ke dalam struktur pohon untuk mewakili hierarki sebagian-keseluruhan.
- Dekorator: Lampirkan tanggung jawab tambahan ke objek secara dinamis.
- Fasad: class tunggal yang mewakili seluruh subsistem.
- Flyweight: Gunakan berbagi untuk mendukung sejumlah besar objek serupa secara efisien.
- Proxy: Berikan pengganti atau placeholder untuk objek lain untuk mengontrol akses ke sana.
- Rantai Tanggung Jawab: Cara menyampaikan permintaan antara rantai objek sampai salah satu dari mereka menanganinya.
- Perintah: Enkapsulasi permintaan sebagai objek, sehingga memungkinkan Anda membuat parameter klien dengan permintaan yang berbeda, antrean atau permintaan log, dan mendukung operasi yang tidak dapat dilakukan.
- Interpreter: Cara untuk memasukkan elemen bahasa dalam program agar sesuai dengan tata bahasa dari bahasa yang dimaksud.
- Iterator: Mengakses elemen koleksi secara berurutan tanpa memaparkan representasi yang mendasarinya.
- Mediator: Tentukan objek yang merangkum bagaimana sekumpulan objek berinteraksi.
- Memories: Tanpa melanggar enkapsulasi, tangkap dan eksternalkan keadaan internal objek yang memungkinkan objek untuk dikembalikan ke keadaan ini nanti.
- Pengamat: Cara memberitahukan perubahan ke sejumlah class.
- Status: Izinkan objek untuk mengubah perilakunya saat status internalnya berubah.
- Strategi: Tetapkan keluarga algoritme, rangkum masing-masing, dan buat mereka dapat dipertukarkan.
- Templat: Menentukan kerangka algoritme dalam suatu operasi, menunda beberapa langkah ke subclass.
- Pengunjung: Mewakili operasi yang akan dilakukan pada elemen struktur objek.
Mari kita pahami Abstract Factory, desain Pembangun & pola Factory Method secara mendetail:
Pola Desain Abstract Factory
Pola Abstract Factory adalah pola desain yang menyediakan antarmuka untuk membuat keluarga objek terkait atau bergantung tanpa menentukan class konkret mereka. Pola ini sering digunakan untuk membuat objek dalam sistem yang terkait dengan tema atau tujuan umum, seperti kumpulan objek GUI atau kumpulan objek yang digunakan untuk melakukan tugas tertentu.
Dalam Python, sebuah Abstract Factory dapat diimplementasikan dengan membuat class abstrak yang mendefinisikan antarmuka untuk membuat objek. class abstrak ini harus menyertakan metode untuk membuat setiap jenis objek yang menjadi milik keluarga. Implementasi konkrit dari Abstract Factory kemudian menyediakan implementasi aktual untuk membuat setiap jenis objek.
Berikut ini contoh bagaimana pola Abstract Factory dapat diimplementasikan dengan Python:
# Abstract class for the factory
class AbstractFactory:
def create_product_a(self):
pass
def create_product_b(self):
pass
# Concrete implementation of the factory
class ConcreteFactory1(AbstractFactory):
def create_product_a(self):
return ConcreteProductA1()
def create_product_b(self):
return ConcreteProductB1()
class ConcreteFactory2(AbstractFactory):
def create_product_a(self):
return ConcreteProductA2()
def create_product_b(self):
return ConcreteProductB2()
# Abstract class for the products
class AbstractProductA:
pass
class AbstractProductB:
pass
# Concrete implementations of the products
class ConcreteProductA1(AbstractProductA):
pass
class ConcreteProductA2(AbstractProductA):
pass
class ConcreteProductB1(AbstractProductB):
pass
class ConcreteProductB2(AbstractProductB):
pass
# Client code
def client_code(factory):
product_a = factory.create_product_a()
product_b = factory.create_product_b()
# Use the products
# ...
if __name__ == "__main__":
factory = ConcreteFactory1()
client_code(factory)
factory = ConcreteFactory2()
client_code(factory)Dalam contoh ini, class Abstract Factory AbstractFactory menentukan antarmuka untuk membuat objek. Implementasi konkret ConcreteFactory1 dan ConcreteFactory2 memberikan implementasi sebenarnya untuk membuat setiap jenis objek. class produk abstrak AbstractProductA dan AbstractProductB mendefinisikan antarmuka untuk produk dan class produk beton ConcreteProductA1, ConcreteProductA2, ConcreteProductB1, dan ConcreteProductB2 menyediakan implementasi sebenarnya untuk produk. Kode klien menggunakan pabrik untuk membuat produk dan kemudian menggunakan produk sesuai kebutuhan.
Pola Abstract Factory berguna untuk membuat objek dalam sistem yang terkait dengan tema atau tujuan umum. Ini memungkinkan kode klien dipisahkan dari implementasi konkret objek, membuatnya lebih mudah untuk mengubah implementasi objek tanpa memengaruhi kode klien. Selain itu, dapat mempermudah pembuatan implementasi objek baru, karena antarmuka untuk membuat objek sudah ditentukan di Abstract Factory.
Pola Desain Builder
Pola pembangun adalah pola desain yang memisahkan konstruksi objek kompleks dari representasinya, memungkinkan proses konstruksi yang sama untuk membuat representasi yang berbeda. Pola ini sering digunakan untuk membuat objek yang memiliki banyak bagian atau komponen opsional, karena pola Builder menyediakan cara untuk menentukan bagian mana yang harus dimasukkan ke dalam objek akhir.
Di Python, class Builder dapat dibuat yang bertanggung jawab untuk membangun objek. class Builder ini harus menyertakan metode untuk menetapkan setiap bagian objek, serta metode untuk mengembalikan objek akhir. Kode klien menggunakan Builder untuk membuat objek dengan memanggil metode untuk menentukan setiap bagian, lalu memanggil metode untuk mengembalikan objek akhir.
Berikut adalah contoh bagaimana pola Builder dapat diterapkan di Python:
# Builder class
class CarBuilder:
def __init__(self):
self._wheels = 4
self._doors = 4
self._type = "sedan"
def set_wheels(self, wheels):
self._wheels = wheels
return self
def set_doors(self, doors):
self._doors = doors
return self
def set_type(self, car_type):
self._type = car_type
return self
def build(self):
return Car(self._wheels, self._doors, self._type)
# Car class
class Car:
def __init__(self, wheels, doors, car_type):
self.wheels = wheels
self.doors = doors
self.type = car_type
def __str__(self):
return f"{self.type} car with {self.wheels} wheels and {self.doors} doors."
# Client code
if __name__ == "__main__":
car_builder = CarBuilder()
car = car_builder.set_type("sedan").set_wheels(4).set_doors(4).build()
print(car)Dalam contoh ini, class Builder CarBuilder bertanggung jawab membangun objek mobil. class CarBuilder mencakup metode untuk menentukan setiap bagian dari objek mobil, serta metode untuk mengembalikan objek akhir. class Mobil merupakan class sederhana yang meliputi jumlah roda, jumlah pintu, dan jenis mobil. Kode klien menggunakan CarBuilder untuk membuat objek Mobil dengan 4 roda, 4 pintu, dan sejenis "sedan".
Pola Builder berguna untuk membuat objek yang memiliki banyak komponen atau bagian opsional. Ini menyediakan cara untuk menentukan bagian mana yang harus disertakan dalam objek akhir, membuatnya lebih mudah untuk membuat objek hanya dengan bagian-bagian yang dibutuhkan. Selain itu, membuat lebih mudah untuk mengubah representasi objek tanpa mempengaruhi kode klien, karena kode klien hanya perlu memanggil metode untuk menentukan setiap bagian dan kemudian memanggil metode untuk mengembalikan objek akhir.
Pola Desain Factory Method
Factory Method adalah pola desain pembuatan yang menyediakan antarmuka untuk membuat objek dalam superclass tetapi memungkinkan subclass untuk mengubah jenis objek yang akan dibuat. Pola Factory Method sering digunakan saat class tidak dapat mengantisipasi jenis objek yang perlu dibuat, atau saat class ingin subclassnya menentukan objek yang dibuatnya.
Di Python, Factory Method dapat diimplementasikan dengan menggunakan metode yang mengembalikan sebuah objek. Metode ini dapat ditimpa dalam subclass untuk membuat objek dengan tipe yang berbeda. Metode di class super harus dipanggil dalam kode klien, yang akan mengembalikan objek dengan tipe yang sesuai.
Berikut adalah contoh bagaimana pola Factory Method dapat diterapkan di Python:
# Creator class
class Creator:
def factory_method(self):
pass
def some_operation(self):
product = self.factory_method()
result = f"Creator: The same creator's code has just worked with {product.operation()}"
return result
# ConcreteCreator class
class ConcreteCreator(Creator):
def factory_method(self):
return ConcreteProduct()
# Product class
class Product:
def operation(self):
pass
# ConcreteProduct class
class ConcreteProduct(Product):
def operation(self):
return "{Result of the ConcreteProduct1}"
# Client code
if __name__ == "__main__":
concrete_creator = ConcreteCreator()
result = concrete_creator.some_operation()
print(result)Dalam contoh ini, class Creator adalah class super yang menyediakan antarmuka untuk membuat objek. class ConcreteCreator adalah subclass yang menggantikan factory_method untuk membuat objek ConcreteProduct. class Produk adalah class abstrak yang menentukan antarmuka untuk objek yang dibuat oleh Factory Method. class ConcreteProduct adalah implementasi konkret dari class Product yang mengembalikan sebuah string dengan hasil operasinya.
Kode klien menggunakan ConcreteCreator untuk membuat objek ConcreteProduct, yang dikembalikan oleh metode factory_. Metode some_operation di class Creator dipanggil, yang menggunakan objek ConcreteProduct untuk melakukan beberapa operasi. Hasil operasi dikembalikan ke kode klien, yang dicetak ke konsol.
Pola Factory Method berguna saat class tidak dapat mengantisipasi jenis objek yang perlu dibuat, atau saat class menginginkan subclassnya untuk menentukan objek yang dibuatnya. Ini menyediakan cara untuk membuat objek tanpa menentukan jenis objek yang akan dibuat, sehingga lebih mudah untuk mengubah jenis objek yang dibuat tanpa mempengaruhi kode klien. Selain itu, ini memungkinkan pembuatan objek yang memiliki antarmuka umum, sehingga memudahkan penggunaan objek secara konsisten.