Design Pattern II

Group Creational Patterns

(cara class/object di-inisiasi)
Melwin Syafrizal, S.Kom., M.Eng.
Abstract
Banyak 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) !rich Gamma,
"ichard #elm, "alph $ohnson dan $ohn %lissides. Dalam The Gang of Four
(GoF) terdapat &' Pattern yang dibagi men(adi ' kelompok besar, yakni)
*reational Patterns (cara class+ob(ect diinisiasi), ,tructural Patterns
(struktur+relasi antar ob(ect+class) dan Beha-ioral Patterns (tingkah laku atau
fungsi dari class+ob(ect.)
Pendahuluan
Creational Pattern, yaitu pola atau teknik pemrograman yang menyangkut
dengan pembuatan ob(ect.
Structural Pattern, yaitu pattern yang menyangkut dengan struktur program.
Bea!ioural Pattern, yaitu pattern yang menyangkut tentang kelakuan"
bea!iour program.
Concurrency Pattern, yaitu pattern yang berubungan dengan konkurensi
dan resource saring.
Creational Patterns terdiri dari#
$. %bstract &actory 'Creates an instance of se!eral families of classes(
). Builder 'Separates ob(ect construction from its representation(
*. &actory Metod 'Creates an instance of se!eral deri!ed classes(
+. Prototype '% fully initialized instance to be copied or cloned(
,. Singleton '% class of wic only a single instance can e-ist(
1. Abstract Factory
Abstract Factory Pattern 'AFP( merupakan sala satu .enis *reational
Pattern yang menangani mekanisme penciptaan ob(ect secara adaptif
%bstract &actory menyediakan sebua interface untuk menciptakan keluarga
yang terkait atau ob(ect yang tergantung tanpa menentukan concrete class
mereka.
%bstract &actory mampu pengenkapsulasian sekelompok factory, dimana
masing/masing factory memiliki 0motif1 kasnya. %&P men.adi sentral
penentuan factory yang akan diinisialisasi seingga product yang diciptakan
dapat mewarisi bea!iour yang sesuai dengan motif yang dipili.
Keistimewaan lain adala product yang diciptakan terbebas dari pernyataan
penciptaan concrete class secara langsung. 2al ini memberikan keuntungan
yaitu %&P dapat mencega coupling problem yang pasti ter.adi apabila
penciptaan ob(ect memakai operator ne dalam baasa 33P.
Gambar 1. UML Class Diagram
4aasia dibalik kemampuan %&P ini terletak pada penyediaan abstraksi
teradap factory dan product yang diasilkan. .bstract factory memberikan
sekumpulan abstract method untuk menciptakan .enis product tertentu yang
arus diimplementasikan ole concrete factory. .bstract product
memberikan abstraksi pada keluarga product yang berbeda motif dimana
tentunya memiliki cara pengimplementasian yang berbeda pula. 5stila
0motif1 dalam paragraf/paragraf sebelumnya diartikan sebagai suatu theme
atau corak kusus yang melekat pada suatu product.
6ntuk memper.elas, katakanla terdapat suatu abstract factory bernama
7oy&actory yang menyediakan fungsi penciptaan beberapa product
'misalnya# create"ace*ar() dan create*uteDoll()(. Sistem kemudian
menarik turunan 7oys&actory karena adanya kebutuan atas corak kusus
tertentu, yaitu 8ooden7oy&actory dan Electric7oy&actory9 dimana keduanya
mampu menciptakan .enis mainan yang berbeda motif 'seperti
8ooden4aceCar dan 8oodenCute:oll, atau Electric4aceCar dan
ElectricCute:oll(. 8ooden dan Electric adala conto dari motif yang
dimaksudkan.
Keberadaan motif umumnya yang men.adi pemicu pemanfaatan %&P dalam
software design dimana setiap concrete factory mampu menciptakan
berbagai concrete product tetapi dalam kesamaan satu .enis motif. Pada
praktik pemakaian %&P, program client akan menginisialisasi suatu
implementasi dari abstract factory dan kemudian menggunakan interface
abstract product ketika ingin memperole atau beker.a dengan ob(ect konkrit
product.
!. "uilder Pattern
Builder Pattern adala sebua software design pattern. 7u.uannya adala
sebagai langka/langka abstract kerangka 'kontruksi( ob(ect, .ika suatu
implementasi menggunakan langka/langka yang berbeda, maka akan
membuat representasi ob(ect yang berbeda .uga.
Builder Pattern sering digunakan untuk membangun produk sesuai dengan
sebua pola struktur *omposite Pattern, dengan cara memisakan
pembangunan kompleks ob(ect dari representation, seingga proses
konstruksi yang sama dapat membuat representation yang berbeda.
Gambar 2. Class :iagram
"uilder
interface abstract untuk membuat ob(ect 'product(.
'menetapkan sebua interface abstract untuk membuat bagian dari
sebua ob(ect 'product((
Concrete"uilder
menyediakan implementasi untuk Builder.
membangun dan merakit bagian/bagian dari produk dengan
menerapkan interface Builder untuk membangun banyak ob(ect
mendefinisikan dan melacak yang mewakili ciptaanya 'kreasinya(
menyediakan interface untuk mengambil product
Director
Class :irector bertanggung .awab untuk mengatur urutan ob(ect kreasi
yang benar.
Menerima Concrete Builder sebagai sebua parameter dan
men.alankan operasi yang diperlukan di atasnya.
Product
ob(ect terakir yang akan diciptakan ole :irector menggunakan
Builder.
mewakili kompleks ob(ect dalam proses pembangunan.
ConcreteBuilder membangun representasi product internal dan
mendefinisikan proses yang menyebabkannya terkumpul
termasuk kelas yang menentukan bagian/bagian penyusunnya, .uga
interface untuk merakit bagian/bagian ke dalam asil akir.
#ips
Builder fokus pada membangun sebua kompleks ob(ect setaap
demi setaap. .bstract Factory menekankan suatu produk keluarga
ob(ect 'baik sederana atau kompleks(. Builder akan
mengembalikan produk sebagai langka terakir, tetapi se.au
menyangkut .bstract Factory, produk akan kembali segera.
Builder sering membangun sebua Composite.
Sering kali, desain awal dengan menggunakan Factory /ethod
'sedikit rumit, lebi muda disesuaikan, subclass berkembang
banyak( dan berkembang ke ara .bstract Factory, Prototype, atau
Builder 'lebi fleksibel, lebi kompleks( sebagai perancang
menemukan di mana fleksibilitas lebi dibutukan.
Kadang/kadang saling melengkapi pola penciptaan# Builder dapat
menggunakan sala satu pola/pola 'patterns( lain untuk
menerapkan komponen yang dibangun. .bstract Factory, Builder,
dan Prototype dapat menggunakan ,ingleton dalam
implementasinya.
Contoh
$a%a
/** "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 set!opping(String topping) {

this.topping = topping;

/** ""bstract #uilder" */
abstract class Pizza#uilder {
protected Pizza pizza;
public Pizza getPizza() {
return pizza;

public void create$e%PizzaProduct() {

pizza = ne% Pizza();

public abstract void buildDough();

public abstract void buildSauce();
public abstract void build!opping();

/** "&oncrete#uilder" */
class 'a%aiianPizza#uilder e(tends Pizza#uilder {
public void buildDough() {
pizza.setDough("cross");

public void buildSauce() {

pizza.setSauce(")ild");

public void build!opping() {

pizza.set!opping("ha)*pineapple");

/** "&oncrete#uilder" */
class Spic+Pizza#uilder e(tends Pizza#uilder {
public void buildDough() {
pizza.setDough("pan ba,ed");

public void buildSauce() {

pizza.setSauce("hot");

public void build!opping() {

pizza.set!opping("pepperoni*sala)i");

/** "Director" */
class &oo, {
private Pizza#uilder pizza#uilder;
public void setPizza#uilder(Pizza#uilder pb) {
pizza#uilder = pb;

public Pizza getPizza() {

return pizza#uilder.getPizza();

public void constructPizza() {

pizza#uilder.create$e%PizzaProduct();
pizza#uilder.buildDough();
pizza#uilder.buildSauce();
pizza#uilder.build!opping();

/** " given t+pe o- pizza being constructed. */
public class #uilder.(a)ple {
public static void )ain(String/0 args) {
&oo, coo, = ne% &oo,();
Pizza#uilder ha%aiianPizza#uilder = ne%
'a%aiianPizza#uilder();
Pizza#uilder spic+Pizza#uilder = ne%
Spic+Pizza#uilder();
coo,.setPizza#uilder(ha%aiianPizza#uilder);
coo,.constructPizza();
Pizza pizza = coo,.getPizza();

Python
1 Product
class Pizza2
de- 33init33(sel-)2
sel-.dough = $one
sel-.sauce = $one
sel-.topping = $one
de- set3dough(sel-4 dough)2
sel-.dough = dough
de- set3sauce(sel-4 sauce)2
sel-.sauce = sauce
de- set3topping(sel-4 topping)2
sel-.topping = topping

1 "bstract #uilder
class Pizza#uilder2
de- 33init33(sel-)2
sel-.pizza = $one
de- get3pizza(sel-)2
return sel-.pizza
de- create3ne%3pizza3product(sel-)2
sel-.pizza = Pizza()

1 &oncrete#uilder
class 'a%aiianPizza#uilder(Pizza#uilder)2
de- build3dough(sel-)2
sel-.pizza.set3dough("cross")
de- build3sauce(sel-)2
sel-.pizza.set3sauce(")ild")
de- build3topping(sel-)2
sel-.pizza.set3topping("ha)*pineapple")

1 Director
class &oo,2
de- 33init33(sel-)2
sel-.pizza3builder = $one
de- set3pizza3builder(sel-4 pb)2
sel-.pizza3builder = pb
de- get3pizza(sel-)2
return sel-.pizza3builder.get3pizza()
de- construct3pizza(sel-)2
sel-.pizza3builder.create3ne%3pizza3product()
sel-.pizza3builder.build3dough()
sel-.pizza3builder.build3sauce()
sel-.pizza3builder.build3topping()

1 " given t+pe o- pizza being constructed.
i- 33na)e33 == 533)ain3352
coo, = &oo,()
coo,.set3pizza3builder('a%aiianPizza#uilder())
coo,.construct3pizza()
pizza = coo,.get3pizza()
&. Factory 'ethod Pattern
:engan membuat Factory /ethod dan mendefinisikan sebua class
interface, kita bisa men/generate ob(ect yang dinamis sesuai kebutuan dan
implementasi yang diinginkan. 2arap di/ingat lagi, ruang lingkup dari Factory
/ethod adala class, Factory /ethod sendiri adala class ob(ect yang static.
Conto di bawa menggambarkan bagaimana 0b(ectFactory memanfaatkan
class interface ob(ect men.adi lebi dinamis. Conto lain implementasi
pattern ini adala BorderFactory atau ,ocketFactory yang merupakan
standart package $a-a .P1.
0bser-er Pattern menerapkan mekanisme Publisher dan ,ubscriber untuk
mengatur bagaimana sebua ob(ect mengetaui perubaan state di ob(ect
lainnya.
Factory 'atri(
:ua al yang perlu ada dalam memakai pattern ini adala keadiran
product dan motif. Product tentunya berkaitan dengan ob(ect apa yang
akan diciptakan ole factory. :an motif berkaitan dengan adanya
kemungkinan product tersebut memiliki cara implementasi yang berbeda
diliat dari .enis teknologi atau alternatif implementasi lain yang membuatnya
memiliki corak yang berbeda. Selain dua al pokok tersebut, penggunaan
pattern ini dimaksudkan untuk memberikan abstraksi saat menciptakan
ob(ect seingga membuatnya dapat independent teradap program client.
6ntuk membantu merangkumnya dapat dipakai Factory /atri2.
;ambar *. &actory Matri-
;ambar di atas memperliatkan &actory Matri- dimana kepala/kolom
menyatakan .enis motif dan kepala/baris menyatakan .enis product.
Sebagai conto kasus# #oys Factory memiliki dua .enis mainan 'sebagai
product( yang dapat diciptakan yaitu )ace Car dan Cute Doll. Padanya .uga
terdapat dua .enis motif yang ingin diterapkan untuk kedua .enis mainan
tersebut yaitu *ooden dan +lectric.
Sel tempat pertemuan antara kolom dan baris merupakan concrete ob(ect
dari satu .enis motif product mainan, conto# 3ooden"ace*ar atau
!lectric*uteDoll. 7entunya di setiap concrete ob(ect ini memiliki cara
implementasi dari abstract beha-iour yang berbeda/beda. :ari matriks ini
kemudian dapat dipetakan ke class diagram dimana product akan men.adi
.bstractProduct dan motif akan men.adi *oncrete Factory.
;ambar +. 2asil pemetaan &actory Matri- 7oys&actory
ke 6M< class diagram.
,. Prototype pattern
Sebua prototype pattern adala sebua design pattern kreatif yang
digunakan dalam pengembangan perangkat lunak. =enis ob(ect untuk
membuat ob(ect baru ditentukan ole prototype conto. 0b(ect di kloning
untuk mengasilkan ob(ect baru.
Pattern ini digunakan untuk#
mengindari subclass dari ob(ect kreator dalam aplikasi klien, tidak
seperti abstract factory pattern.
mengindari biaya yang melekat (inherent cost) dari ob(ect baru
yang dibuat sesuai standar 'misalnya, dengan menggunakan
keyword > ne >(, saat biaya itu cukup maal untuk aplikasi tertentu.
6ntuk mengimplementasikan pattern, deklarasikan sebua abstract base
class yang menentukan sebua pure -irtual clone () method. Setiap class
yang memerlukan sebua 0polymorphic constructor1, maka kemampuan itu
berasal dari class abstract base dirinya sendiri, dan mengimplementasikan
operasi clone ().
Klien, bukanya menulis kode yang meminta operator ?new? pada sebua
hard-coded class name, memanggil method clone () pada prototipe,
memanggil sebua factory method dengan sebua parameter tertentu yang
menun.uk particular concrete kelas turunan yang diinginkan, atau
mengacu pada method clone () melalui beberapa mekanisme yang
disediakan ole design pattern lain.
Contoh
Prototype Pattern menentukan .enis ob(ect untuk membuat sebua prototype
conto. Prototipe produk baru sering dibangun sebelum memproduksi
masal, tetapi dalam conto ini, prototype adala pasif dan tidak
berpartisipasi dalam menyalin diri sendiri. Pembelaan mitosis sel /
berakibat dua sel identik, dan ini adala conto dari prototipe yang
memainkan peran aktif dalam menyalin dirinya sendiri dan al ini
menun.ukkan Prototype pattern. Ketika sebua sel membela diri, maka dua
sel yang identik asil genotype akan tercipta. :engan kata lain, sel tersebut
meng/klon dirinya sendiri. @Micael :uell, ?Aon/software e-amples of
software design patterns?, 0b(ect Magazine, =ul BC, p,+D.
Java
/**
* Protot+pe &lass
*/
public class &oo,ie i)ple)ents &loneable {

67verride
public &oo,ie clone() thro%s
&lone$otSupported.(ception {
// call Object.clone()
&oo,ie cop+ = (&oo,ie) super.clone();

//8n an actual i)ple)entation o- this pattern
+ou )ight no% change re-erences to
//the e(pensive to produce parts -ro) the copies
that are held inside the protot+pe.

return cop+;

/**
* &oncrete Protot+pes to clone
*/
public class &oconut&oo,ie e(tends &oo,ie {
/**
* &lient &lass
*/
public class &oo,ie9achine {

private &oo,ie coo,ie; // &ould have been a private
&loneable coo,ie.

public &oo,ie9achine(&oo,ie coo,ie) {
this.coo,ie = coo,ie;


public &oo,ie )a,e&oo,ie() {
return (&oo,ie) this.coo,ie.clone();


public static void )ain(String args/0) {
&oo,ie te)p&oo,ie = null;
&oo,ie prot = ne% &oconut&oo,ie();
&oo,ie9achine c) = ne% &oo,ie9achine(prot);
-or (int i = :; i ; <::; i**)
te)p&oo,ie = c).)a,e&oo,ie();

Python
i)port cop+

1
1 Protot+pe &lass
1
class &oo,ie2
de- 33init33(sel-4 na)e)2
sel-.na)e = na)e

de- clone(sel-)2
return cop+.deepcop+(sel-)

1
1 &oncrete Protot+pes to clone
1
class &oconut&oo,ie(&oo,ie)2
de- 33init33(sel-)2
&oo,ie.33init33(sel-4 5&oconut5)

1 &lient &lass
class &oo,ie9achine2
de- 33init33(sel-4 coo,ie)2
sel-.coo,ie = coo,ie

de- )a,e3coo,ie(sel-)2
return sel-.coo,ie.clone()

i- 33na)e33 == 533)ain3352
prot = &oconut&oo,ie()
c) = &oo,ie9achine(prot)
-or i in (range(<:)2
te)p3coo,ie = c).)a,e3coo,ie()
Aturan yang perlu diperhati-an
Kadang/kadang creational patterns tumpang tindi / ada kasus/kasus ketika
baik Prototype atau %bstract &actory akan sesuai. :i lain waktu mereka
saling melengkapi satu sama lain# %bstract &actory mungkin menyimpan set
Prototype dari yang untuk mengkloning dan produk kembali ob(ect ';3&,
p$)E(. %bstract &actory, Builder, dan Prototipe dapat menggunakan
Singleton dalam implementasi. ';o&, pF$, $*+(. ';3&, pF$, $*+(. %bstract
&actory classes sering dilaksanakan dengan Metode Pabrik 'penciptaan
melalui pewarisan(, tetapi mereka dapat diimplementasikan dengan
menggunakan Prototype 'ciptaan melalui delegasi(. ';o&, pB,( ';3&, pB,(
Sering kali, desain awal dengan menggunakan Metode Pabrik 'kurang rumit,
lebi disesuaikan, subclass berkembang biak( dan berkembang ke ara
%bstract &actory, Prototype, atau Builder 'lebi fleksibel, lebi kompleks(
sebagai perancang menemukan di mana fleksibilitas lebi dibutukan. ';o&,
p$*E( ';3&, p$*E(
Prototype tidak memerlukan subclassing, tapi itu tidak memerlukan sebua
?initialize? operasi. Metode factory memerlukan subclassing, tapi tidak
memerlukan inisialisasi. ';o&, p$$E( ';3&, p$$E(
:esain yang membuat penggunaan berat Composite dan decorator pattern
sering dapat memperole manfaat dari Prototype .uga. ';o&, p$)E( ';3&,
p$)E(
4ule of tumb bisa .adi %nda akan perlu untuk mengkloning '( sebua
0b(ect ketika %nda ingin membuat 0b(ect lain pada saat runtime yang
merupakan sebua true copy 0b(ect kloning %nda. True copy berarti seluru
atribut yang baru dibuat arus 0b(ect yang sama dengan 0b(ect yang %nda
kloning. =ika %nda bisa instantiated class dengan menggunakan bukan baru,
%nda akan mendapatkan 0b(ect dengan semua atribut sebagai nilai awal.
Sebagai conto, .ika %nda merancang suatu sistem untuk melakukan
transaksi rekening bank, maka %nda akan ingin untuk membuat salinan dari
0b(ect yang memegang informasi account %nda, melakukan transaksi di
atasnya, dan kemudian mengganti 0b(ect asli dengan yang diuba satu.
:alam kasus tersebut, %nda akan ingin menggunakan clone '( bukan baru.
.. /ingleton Pattern
,ingleton pattern adala design pattern yang digunakan untuk membatasi
instanisasi dari suatu kelas men.adi satu ob(ect, membatasi sebua global
point of access ke suatu ob(ect dan memperbolekan multiple instances ke
depan tanpa mempengarui singleton class client. 7erkadang suatu sistem
akan beroperasi lebi efisien .ika anya ada satu atau beberapa ob(ect sa.a.
,ingleton pattern diimplementasikan dengan membuat class dengan
method yang membuat instance class yang baru .ika instance belum ada.
=ika instance suda ada maka akan diarakan ob(ect yang tela ada. 6ntuk
mencega ob(ect tidak instankan berkali/kali maka constructor diruba
men.adi pri-ate atau protected, protected constructor bisa dipanggil ole
subclass dan class yang berada dalam satu package, .ika pri-ate
constructor maka anya bisa dipanggil ole class itu sendiri tetapi itu berarti
class tersebut tidak bisa di subclass/kan.
/*
public class satu {
private static -inal satu instance = ne% satu();
/** &reates a ne% instance o- satu */
private satu() {
S+ste).out.println("satu");

public static satu get8nstance() {
return instance;

/*
* dua.=ava
public class dua {
/** &reates a ne% instance o- dua */
public dua() {
public static void )ain(String/0 args)
{
satu s = satu.get8nstance();


:%&7%4 P6S7%K%
)GGF, 5ntroducing 7o :esign Pattern, ttp#""ale-budiyanto.web.id"introducing/
to/design/pattern.tml
ttp#""en.wikipedia.org"wiki"BuilderHpattern
%pa itu Abstract Factory Pattern?
ttp#"".osef.web.id"se")GGC"G,"GE"apa/itu/abstract/factory/pattern"
Gamma, Erich; Helm, ichar!; "ohnson, alph; #lissi!es, "ohn
$1%%&'. Design Patterns: Elements of Reusable Object-
Oriented Software. (!!ison)*esle+. ,-./ 0)201)12211)2.