Abstract Factory Design Pattern

Pengertian

Abstract Factory Pattern  merupakan salah satu jenis Creational Pattern yang menangani mekanisme penciptaan objek secara adaptif sehingga suatu objek tidak harus selalu sama dan di hard code scara langsung. Abstract Factory Pattern memberikan kemampuan pengenkapsulasian sekelompok factory dimana masing-masing factory memiliki pattern  tersendiri. 

Abstract Factory Design Pattern menjadi sentral penentuan factory yang akan diinisialisasi sehingga product yang diciptakan dapat mewarisi behaviour yang sesuai dengan pattern yang dipilih. Dengan kata lain, dapat disimpulkan bahwa abstract factory pattern merupakan “Factory of Factories “. Keistimewaan lain adalah product yang diciptakan terbebas dari dependency penciptaan concrete class secara langsung. Hal ini memberikan keuntungan yaitu Abstract Factory Pattern dapat mencegah coupling problem yang pasti terjadi apabila penciptaan objek memakai operator new. 

Kata kunci utama dari abstract factory design pattern ialah, client tidak pernah menciptakan suatu concrete class secara langsung, mereka meminta “factory” untuk menciptakannya.

Partisipan Abstract Factory Design

1. Abstract factory, digunakan untuk mendklarasi interface  didalam pembuatan pengoperasian pada objek abstract factory.
2. Concrete factory, digunakan untuk mengimplementasikan operasi didalam pembuatan concrete object produk dari abstract factory.
3. Abstract product, digunakan untuk mendeklarasikan interface untuk tipe objek produk.
4. Concrete product, untuk mendefinisikan produk objek atau mengimplementasikan produk dari Abstract produk.
5. Clients, digunakan untuk mendeklrasikan atau memanggil interface by Abstract factory dan abstract produk.  

Tujuan

Menyediakan interface untuk menciptakan family of related atau dependent object tanpa harus menspesifikasikan concrete class objek tersebut. 

UML Class Diagram

Kelebihan

• Dapat digunakan untuk pembuatan yang memungkinkan banyak method dan modul yang bersifat multiplie
• Menjadikan sebuah desain aplikasi menjadi terstruktur

Kekurangan

• harus mendefinisikan sebuah family  atau abstract produk jika ingin menambahkan sebuah produk yang tidak termasuk dalam family yang sudah ada.
• jumlah kelas akan semakin banyak

Implementation

kasus : Menu makanan

	package Java;
	public abstract class AbstractFactory {
	abstracy Makanan getMakanan(String makanan);
	abstract Minuman getMinuman(String minuman);
	}

view raw AbstractFactory.java hosted with ❤ by GitHub

Kita membuat abstract class dimana disini kita tidak dapat menginstansiasi atau mengimplementasi object. Hanya dapat diimplementasikan oleh turunan classnya.

	Package class MakananFactory extends AbstractFactory {
	@Override
	Makanan getMakanan(String makanan) {
	if (makanan.equals(JenisMakanan.Nasi_Goreng)){
	return new NasiGoreng();
	}
	else if (makanan.equals(JenisMakanan.Nasi_Padang)){
	return new NasiPadang();
	}
	else if (makanan.equals(JenisMakanan.Nasi_Uduk)){
	return new NasiUduk();
	}
	Return null;
	}
	@Override
	Makanan getMakanan(String makanan){
	Return null;
	}
	}

view raw MakananFactory.java hosted with ❤ by GitHub

	Package class MinumanFactory extends AbstractFactory {
	@Override
	Minuman getMinuman(String minuman) {
	if (minuman.equals(JenisMinuman.Teh_Tawar)){
	return new TehTawar();
	}
	else if (minuman.equals(JenisMinuman.Teh_Manis)){
	return new TehManis();
	}
	else if (minuman.equals(JenisMinuman.Teh_Hijau)){
	return new TehHijau();
	}
	Return null;
	}
	@Override
	Minuman getMinuman(String minuman){
	Return null;
	}
	}

view raw MinumanFactory.java hosted with ❤ by GitHub

Terdapat 2 file terpisah yaitu concrete factory dari abstract factory adalah MinumanFactory.java dan MakananFactory.java yang mewariskan method pada abstract class AbstractFactory.java dengan keyword extends.

	public interface Makanan{
	void harga();
	}
	package Java.
	public interface Minuman{
	void rasa();
	}

view raw produk.java hosted with ❤ by GitHub

Kita membuat 2 interface pada file yang terpisah. Untuk di implementasikan ke Concreate Class

	package Java;
	public class TehHijau implements Minuman{
	private String namaMinuman = TehHijau.class.getSimpleName();
	@Override
	public void rasa{
	//…….
	}
	}
	public class TehManis implements Minuman{
	private String namaMinuman = TehManis.class.getSimpleName();
	@Override
	public void rasa{
	//…….
	}
	}
	public class TehTawar implements Minuman{
	private String namaMinuman = TehTawar.class.getSimpleName();
	@Override
	public void rasa{
	//…….
	}
	}

view raw minuman.java hosted with ❤ by GitHub

Ini merupakan concreate class yang dibuat untuk mengimplementasikan method dari interface Minuman.java dengan keyword implements. Sama halnya seperti concreate class pada Makanan.java tinggal diubah saja menjadi makanan dan masukan jenis-jenis makanannya.

Kesimpulan

Abstract Factory Pattern memberikan kemampuan pengenkapsulasian sekelompok factory dimana masing-masing factory memiliki pattern  tersendiri. Abstract Factory Design Pattern menjadi sentral penentuan factory yang akan diinisialisasi sehingga product yang diciptakan dapat mewarisi behaviour yang sesuai dengan pattern yang dipilih. Dengan kata lain, dapat disimpulkan bahwa abstract factory pattern merupakan “Factory of Factories “.