Design Pattern II

Design Pattern IIGroup Creational Patterns(cara class/object di-inisiasi)

Melwin Syafrizal, S.Kom., M.Eng.AbstractBanyak Design Patterns yang sudah diakui kemampuannya, diterima dan diaplikasikan oleh banyak praktisi. Design Patterns yang cukup populer adalah yang diperkenalkan The Gang of Four (GoF) - Erich Gamma, Richard Helm, Ralph Johnson dan John Vlissides. Dalam The Gang of Four (GoF) terdapat 23 Pattern yang dibagi menjadi 3 kelompok besar, yakni: Creational Patterns (cara class/object di-inisiasi), Structural Patterns (struktur/relasi antar object/class) dan Behavioral Patterns (tingkah laku atau fungsi dari class/object.)Pendahuluan

Creational Pattern, yaitu pola atau teknik pemrograman yang menyangkut dengan pembuatan object.Structural Pattern, yaitu pattern yang menyangkut dengan struktur program.Behavioural Pattern, yaitu pattern yang menyangkut tentang kelakuan/ behaviour program.Concurrency Pattern, yaitu pattern yang berhubungan dengan konkurensi dan resource sharing.Creational Patterns terdiri dari:1. Abstract Factory (Creates an instance of several families of classes)

2. Builder (Separates object construction from its representation)3. Factory Method (Creates an instance of several derived classes)4. Prototype (A fully initialized instance to be copied or cloned)

5. Singleton (A class of which only a single instance can exist)1. Abstract FactoryAbstract Factory Pattern (AFP) merupakan salah satu jenis Creational Pattern yang menangani mekanisme penciptaan object secara adaptif Abstract Factory menyediakan sebuah interface untuk menciptakan keluarga yang terkait atau object yang tergantung tanpa menentukan concrete class mereka.

Abstract Factory mampu pengenkapsulasian sekelompok factory, dimana masing-masing factory memiliki motif khasnya. AFP menjadi sentral penentuan factory yang akan diinisialisasi sehingga product yang diciptakan dapat mewarisi behaviour yang sesuai dengan motif yang dipilih. Keistimewaan lain adalah product yang diciptakan terbebas dari pernyataan penciptaan concrete class secara langsung. Hal ini memberikan keuntungan yaitu AFP dapat mencegah coupling problem yang pasti terjadi apabila penciptaan object memakai operator new dalam bahasa OOP.

Gambar 1. UML Class DiagramRahasia dibalik kemampuan AFP ini terletak pada penyediaan abstraksi terhadap factory dan product yang dihasilkan. Abstract factory memberikan sekumpulan abstract method untuk menciptakan jenis product tertentu yang harus diimplementasikan oleh concrete factory. Abstract product memberikan abstraksi pada keluarga product yang berbeda motif dimana tentunya memiliki cara pengimplementasian yang berbeda pula. Istilah motif dalam paragraf-paragraf sebelumnya diartikan sebagai suatu theme atau corak khusus yang melekat pada suatu product. Untuk memperjelas, katakanlah terdapat suatu abstract factory bernama ToyFactory yang menyediakan fungsi penciptaan beberapa product (misalnya: createRaceCar() dan createCuteDoll()). Sistem kemudian menarik turunan ToysFactory karena adanya kebutuhan atas corak khusus tertentu, yaitu WoodenToyFactory dan ElectricToyFactory; dimana keduanya mampu menciptakan jenis mainan yang berbeda motif (seperti WoodenRaceCar dan WoodenCuteDoll, atau ElectricRaceCar dan ElectricCuteDoll). Wooden dan Electric adalah contoh dari motif yang dimaksudkan. Keberadaan motif umumnya yang menjadi pemicu pemanfaatan AFP dalam software design dimana setiap concrete factory mampu menciptakan berbagai concrete product tetapi dalam kesamaan satu jenis motif. Pada praktik pemakaian AFP, program client akan menginisialisasi suatu implementasi dari abstract factory dan kemudian menggunakan interface abstract product ketika ingin memperoleh atau bekerja dengan object konkrit product.2. Builder Pattern

Builder Pattern adalah sebuah software design pattern. Tujuannya adalah sebagai langkah-langkah abstract kerangka (kontruksi) object, jika suatu implementasi menggunakan langkah-langkah yang berbeda, maka akan membuat representasi object yang berbeda juga. Builder Pattern sering digunakan untuk membangun produk sesuai dengan sebuah pola struktur Composite Pattern, dengan cara memisahkan pembangunan kompleks object dari representation, sehingga proses konstruksi yang sama dapat membuat representation yang berbeda.

Gambar 2. Class DiagramBuilder interface abstract untuk membuat object (product).(menetapkan sebuah interface abstract untuk membuat bagian dari sebuah object (product))ConcreteBuilder menyediakan implementasi untuk Builder. membangun dan merakit bagian-bagian dari produk dengan menerapkan interface Builder untuk membangun banyak object mendefinisikan dan melacak yang mewakili ciptaanya (kreasinya) menyediakan interface untuk mengambil productDirector Class Director bertanggung jawab untuk mengatur urutan object kreasi yang benar. Menerima Concrete Builder sebagai sebuah parameter dan menjalankan operasi yang diperlukan di atasnya.Product object terakhir yang akan diciptakan oleh Director menggunakan Builder. mewakili kompleks object dalam proses pembangunan. ConcreteBuilder membangun representasi product internal dan mendefinisikan proses yang menyebabkannya terkumpul termasuk kelas yang menentukan bagian-bagian penyusunnya, juga interface untuk merakit bagian-bagian ke dalam hasil akhir.Tips Builder fokus pada membangun sebuah kompleks object setahap demi setahap. Abstract Factory menekankan suatu produk keluarga object (baik sederhana atau kompleks). Builder akan mengembalikan produk sebagai langkah terakhir, tetapi sejauh menyangkut Abstract Factory, produk akan kembali segera. Builder sering membangun sebuah Composite. Sering kali, desain awal dengan menggunakan Factory Method (sedikit rumit, lebih mudah disesuaikan, subclass berkembang banyak) dan berkembang ke arah Abstract Factory, Prototype, atau Builder (lebih fleksibel, lebih kompleks) sebagai perancang menemukan di mana fleksibilitas lebih dibutuhkan. Kadang-kadang saling melengkapi pola penciptaan: Builder dapat menggunakan salah satu pola-pola (patterns) lain untuk menerapkan komponen yang dibangun. Abstract Factory, Builder, dan Prototype dapat menggunakan Singleton dalam implementasinya.ContohJava/** "Product" */

class Pizza {

private String dough = "";

private String sauce = "";

private String topping = "";

public void setDough(String dough) {

this.dough = dough;

}

public void setSauce(String sauce) {

this.sauce = sauce;

}

public void setTopping(String topping) {

this.topping = topping;

}

}

/** "Abstract Builder" */

abstract class PizzaBuilder {

protected Pizza pizza;

public Pizza getPizza() {

return pizza;

}

public void createNewPizzaProduct() {

pizza = new Pizza();

}

public abstract void buildDough();

public abstract void buildSauce();

public abstract void buildTopping();

}

/** "ConcreteBuilder" */

class HawaiianPizzaBuilder extends PizzaBuilder {

public void buildDough() {

pizza.setDough("cross");

}

public void buildSauce() {

pizza.setSauce("mild");

}

public void buildTopping() {

pizza.setTopping("ham+pineapple");

}

}

/** "ConcreteBuilder" */

class SpicyPizzaBuilder extends PizzaBuilder {

public void buildDough() {

pizza.setDough("pan baked");

}

public void buildSauce() {

pizza.setSauce("hot");

}

public void buildTopping() {

pizza.setTopping("pepperoni+salami");

}

}

/** "Director" */

class Cook {

private PizzaBuilder pizzaBuilder;

public void setPizzaBuilder(PizzaBuilder pb) {

pizzaBuilder = pb;

}

public Pizza getPizza() {

return pizzaBuilder.getPizza();

}

public void constructPizza() {

pizzaBuilder.createNewPizzaProduct();

pizzaBuilder.buildDough();

pizzaBuilder.buildSauce();

pizzaBuilder.buildTopping();

}

}

/** A given type of pizza being constructed. */

public class BuilderExample {

public static void main(String[] args) {

Cook cook = new Cook();

PizzaBuilder hawaiianPizzaBuilder = new HawaiianPizzaBuilder();

PizzaBuilder spicyPizzaBuilder = new SpicyPizzaBuilder();

cook.setPizzaBuilder(hawaiianPizzaBuilder);

cook.constructPizza();

Pizza pizza = cook.getPizza();

}

}

Python

# Product

class Pizza:

def __init__(self):

self.dough = None

self.sauce = None

self.topping = None

def set_dough(self, dough):

self.dough = dough

def set_sauce(self, sauce):

self.sauce = sauce

def set_topping(self, topping):

self.topping = topping

# Abstract Builder

class PizzaBuilder:

def __init__(self):

self.pizza = None

def get_pizza(self):

return self.pizza

def create_new_pizza_product(self):

self.pizza = Pizza()

# ConcreteBuilder

class HawaiianPizzaBuilder(PizzaBuilder):

def build_dough(self):

self.pizza.set_dough("cross")

def build_sauce(self):

self.pizza.set_sauce("mild")

def build_topping(self):

self.pizza.set_topping("ham+pineapple")

# Director

class Cook:

def __init__(self):

self.pizza_builder = None

def set_pizza_builder(self, pb):

self.pizza_builder = pb

def get_pizza(self):

return self.pizza_builder.get_pizza()

def construct_pizza(self):

self.pizza_builder.create_new_pizza_product()

self.pizza_builder.build_dough()

self.pizza_builder.build_sauce()

self.pizza_builder.build_topping()

# A given type of pizza being constructed.

if __name__ == '__main__':

cook = Cook()

cook.set_pizza_builder(HawaiianPizzaBuilder())

cook.construct_pizza()

pizza = cook.get_pizza()

3. Factory Method Pattern

Dengan membuat Factory Method dan mendefinisikan sebuah class interface, kita bisa men-generate object yang dinamis sesuai kebutuhan dan implementasi yang diinginkan. Harap di-ingat lagi, ruang lingkup dari Factory Method adalah class, Factory Method sendiri adalah class object yang static.

Contoh di bawah menggambarkan bagaimana ObjectFactory memanfaatkan class interface object menjadi lebih dinamis. Contoh lain implementasi pattern ini adalah BorderFactory atau SocketFactory yang merupakan standart package Java API.

Observer Pattern menerapkan mekanisme Publisher dan Subscriber untuk mengatur bagaimana sebuah object mengetahui perubahan state di object lainnya.

Factory MatrixDua hal yang perlu ada dalam memakai pattern ini adalah kehadiran product dan motif. Product tentunya berkaitan dengan object apa yang akan diciptakan oleh factory. Dan motif berkaitan dengan adanya kemungkinan product tersebut memiliki cara implementasi yang berbeda dilihat dari jenis teknologi atau alternatif implementasi lain yang membuatnya memiliki corak yang berbeda. Selain dua hal pokok tersebut, penggunaan pattern ini dimaksudkan untuk memberikan abstraksi saat menciptakan object sehingga membuatnya dapat independent terhadap program client. Untuk membantu merangkumnya dapat dipakai Factory Matrix.

Gambar 3. Factory MatrixGambar di atas memperlihatkan Factory Matrix dimana kepala-kolom menyatakan jenis motif dan kepala-baris menyatakan jenis product. Sebagai contoh kasus: Toys Factory memiliki dua jenis mainan (sebagai product) yang dapat diciptakan yaitu Race Car dan Cute Doll. Padanya juga terdapat dua jenis motif yang ingin diterapkan untuk kedua jenis mainan tersebut yaitu Wooden dan Electric. Sel tempat pertemuan antara kolom dan baris merupakan concrete object dari satu jenis motif product mainan, contoh: WoodenRaceCar atau ElectricCuteDoll. Tentunya di setiap concrete object ini memiliki cara implementasi dari abstract behaviour yang berbeda-beda. Dari matriks ini kemudian dapat dipetakan ke class diagram dimana product akan menjadi AbstractProduct dan motif akan menjadi Concrete Factory.

Gambar 4. Hasil pemetaan Factory Matrix ToysFactory ke UML class diagram.

4.Prototype pattern

Sebuah prototype pattern adalah sebuah design pattern kreatif yang digunakan dalam pengembangan perangkat lunak. Jenis object untuk membuat object baru ditentukan oleh prototype contoh. Object di kloning untuk menghasilkan object baru. Pattern ini digunakan untuk:

menghindari subclass dari object kreator dalam aplikasi klien, tidak seperti abstract factory pattern.

menghindari biaya yang melekat (inherent cost) dari object baru yang dibuat sesuai standar (misalnya, dengan menggunakan keyword 'new'), saat biaya itu cukup mahal untuk aplikasi tertentu.

Untuk mengimplementasikan pattern, deklarasikan sebuah abstract base class yang menentukan sebuah pure virtual clone () method. Setiap class yang memerlukan sebuah polymorphic constructor, maka kemampuan itu berasal dari class abstract base dirinya sendiri, dan mengimplementasikan operasi clone ().

Klien, bukanya menulis kode yang meminta operator "new" pada sebuah hard-coded class name, memanggil method clone () pada prototipe, memanggil sebuah factory method dengan sebuah parameter tertentu yang menunjuk particular concrete kelas turunan yang diinginkan, atau mengacu pada method clone () melalui beberapa mekanisme yang disediakan oleh design pattern lain.

ContohPrototype Pattern menentukan jenis object untuk membuat sebuah prototype contoh. Prototipe produk baru sering dibangun sebelum memproduksi masal, tetapi dalam contoh ini, prototype adalah pasif dan tidak berpartisipasi dalam menyalin diri sendiri. Pembelahan mitosis sel - berakibat dua sel identik, dan ini adalah contoh dari prototipe yang memainkan peran aktif dalam menyalin dirinya sendiri dan hal ini menunjukkan Prototype pattern. Ketika sebuah sel membelah diri, maka dua sel yang identik hasil genotype akan tercipta. Dengan kata lain, sel tersebut meng-klon dirinya sendiri. [Michael Duell, "Non-software examples of software design patterns", Object Magazine, Jul 97, p54].

Java/**

* Prototype Class

*/public class Cookie implements Cloneable { @Override

public Cookie clone() throws CloneNotSupportedException { // call Object.clone() Cookie copy = (Cookie) super.clone(); //In an actual implementation of this pattern you might now change references to //the expensive to produce parts from the copies that are held inside the prototype. return copy; }}/**

* Concrete Prototypes to clone

*/public class CoconutCookie extends Cookie { }/**

* Client Class

*/public class CookieMachine { private Cookie cookie; // Could have been a private Cloneable cookie. public CookieMachine(Cookie cookie) { this.cookie = cookie; } public Cookie makeCookie() { return (Cookie) this.cookie.clone(); } public static void main(String args[]) { Cookie tempCookie = null; Cookie prot = new CoconutCookie(); CookieMachine cm = new CookieMachine(prot); for (int i = 0; i < 100; i++) tempCookie = cm.makeCookie(); }}Pythonimport copy## Prototype Class#class Cookie:

def __init__(self, name):

self.name = name

def clone(self):

return copy.deepcopy(self)## Concrete Prototypes to clone#class CoconutCookie(Cookie):

def __init__(self):

Cookie.__init__(self, 'Coconut')# Client Classclass CookieMachine:

def __init__(self, cookie):

self.cookie = cookie

def make_cookie(self):

return self.cookie.clone()if __name__ == '__main__':

prot = CoconutCookie() cm = CookieMachine(prot) for i in xrange(10):

temp_cookie = cm.make_cookie()Aturan yang perlu diperhatikan

Kadang-kadang creational patterns tumpang tindih - ada kasus-kasus ketika baik Prototype atau Abstract Factory akan sesuai. Di lain waktu mereka saling melengkapi satu sama lain: Abstract Factory mungkin menyimpan set Prototype dari yang untuk mengkloning dan produk kembali object (GOF, p126). Abstract Factory, Builder, dan Prototipe dapat menggunakan Singleton dalam implementasi. (GoF, p81, 134). (GOF, p81, 134). Abstract Factory classes sering dilaksanakan dengan Metode Pabrik (penciptaan melalui pewarisan), tetapi mereka dapat diimplementasikan dengan menggunakan Prototype (ciptaan melalui delegasi). (GoF, p95) (GOF, p95)

Sering kali, desain awal dengan menggunakan Metode Pabrik (kurang rumit, lebih disesuaikan, subclass berkembang biak) dan berkembang ke arah Abstract Factory, Prototype, atau Builder (lebih fleksibel, lebih kompleks) sebagai perancang menemukan di mana fleksibilitas lebih dibutuhkan. (GoF, p136) (GOF, p136)

Prototype tidak memerlukan subclassing, tapi itu tidak memerlukan sebuah "initialize" operasi. Metode factory memerlukan subclassing, tapi tidak memerlukan inisialisasi. (GoF, p116) (GOF, p116)

Desain yang membuat penggunaan berat Composite dan decorator pattern sering dapat memperoleh manfaat dari Prototype juga. (GoF, p126) (GOF, p126)

Rule of thumb bisa jadi Anda akan perlu untuk mengkloning () sebuah Object ketika Anda ingin membuat Object lain pada saat runtime yang merupakan sebuah true copy Object kloning Anda. True copy berarti seluruh atribut yang baru dibuat harus Object yang sama dengan Object yang Anda kloning. Jika Anda bisa instantiated class dengan menggunakan bukan baru, Anda akan mendapatkan Object dengan semua atribut sebagai nilai awal. Sebagai contoh, jika Anda merancang suatu sistem untuk melakukan transaksi rekening bank, maka Anda akan ingin untuk membuat salinan dari Object yang memegang informasi account Anda, melakukan transaksi di atasnya, dan kemudian mengganti Object asli dengan yang diubah satu. Dalam kasus tersebut, Anda akan ingin menggunakan clone () bukan baru.

5. Singleton Pattern

Singleton pattern adalah design pattern yang digunakan untuk membatasi instanisasi dari suatu kelas menjadi satu object, membatasi sebuah global point of access ke suatu object dan memperbolehkan multiple instances ke depan tanpa mempengaruhi singleton class client. Terkadang suatu sistem akan beroperasi lebih efisien jika hanya ada satu atau beberapa object saja.

Singleton pattern diimplementasikan dengan membuat class dengan method yang membuat instance class yang baru jika instance belum ada. Jika instance sudah ada maka akan diarahkan object yang telah ada. Untuk mencegah object tidak instankan berkali-kali maka constructor dirubah menjadi private atau protected, protected constructor bisa dipanggil oleh subclass dan class yang berada dalam satu package, jika private constructor maka hanya bisa dipanggil oleh class itu sendiri tetapi itu berarti class tersebut tidak bisa di subclass-kan.

/*public class satu {private static final satu instance = new satu();/** Creates a new instance of satu */ private satu() {System.out.println("satu");}public static satu getInstance() {return instance;} }

/** dua.java

public class dua {

/** Creates a new instance of dua */public dua() {}

public static void main(String[] args){ satu s = satu.getInstance();}}

DAFTAR PUSTAKA

2008, Introducing To Design Pattern, http://alexbudiyanto.web.id/introducing-to-design-pattern.html

http://en.wikipedia.org/wiki/Builder_patternApa itu Abstract Factory Pattern? http://josef.web.id/se/2007/05/06/apa-itu-abstract-factory-pattern/Gamma, Erich; Helm, Richard; Johnson, Ralph; Vlissides, John (1994). Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley. ISBN 0-201-63361-2.