Design
Pattern adalah sebuah istilah (English) dalam Rekayasa PerangkatLunak (Software
Engineering) yang mengacu kepada solusi umum yangdapat digunakan secara
berulang kali untuk menyelesaikan masalah-masalah umum yang ditemukan dalam
disain perangkat lunak. Sebuah design pattern tidak berbentuk solusi akhir yang
dapat langsungditerjemahkan menjadi kode program.
Design
pattern merupakan penjelasan atau template yang menunjukkanbagaimana cara
menyelesaikan sebuah masalah yang kemudian dapatdigunakan di berbagai situasi
yang berbeda-beda.
Design
pattern untuk object-oriented biasanya menunjukkan relasi dan interaksi antar
kelas danobjek, tanpa menjelaskan kelas dan objek akhir yang terlibat dalam
sebuahaplikasi. Algoritma biasanya tidak disebut sebagai design pattern,
karenaalgoritma akan menjadi solusi masalah komputasi dan bukan masalahdisain
Ada 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) - Erich Gamma,
RichardHelm, Ralph Johnson dan John Vlissides. Dalam The Gang of Four (GoF)terdapat
23 Pattern yang dibagi menjadi 3 kelompok besar, sebagai berikut :
Creational Patterns (cara class/object
di-inisiasi).
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)
Structural Patterns(struktur/relasi antar object/class)
1. Adapter (Match interfaces of different
classes)
2.Bridge(Separates an object’s interface from its
implementation)
3.Composite(A tree structure of simple and composite
objects)
4.Decorator (Add responsibilities to objects dynamically)
5.Facade(A single class that represents an entire
subsystem)
6.Flyweight (A fine-grained instance used for efficient sharing)
7.Proxy(An object representing another object)
Behavioral Patterns (tingkah
laku atau fungsi dari class/object.)
1.Chain of Responbility(A way of passing a
request between a chainof objects)
2.Command(Encapsulate a command request as an object)
3.Interpreter (A way to include language elements in a
program)
4.Iterator (Sequentially access the elements of a
collection)
Disini saya akan menjelaskan
mengenasi salah satu contoh design pattern yaitu Abstract Factory.
Abstract Factory Pattern desain
perangkat lunak pola yang menyediakan cara untuk merangkum sekelompok pabrik
individu yang memiliki tema umum. Dalam penggunaan normal, perangkat lunak
klien menciptakan implementasi konkret dari pabrik abstrak (Abstrack Factory)
dan kemudian menggunakan antarmuka generik untuk membuat objek konkret yang
merupakan bagian dari tema. Klien tidak tahu (atau peduli) yang objek konkret
karena mendapat dari masing-masing pabrik internal yang karena hanya
menggunakan antarmuka generik dari produk mereka. Pola ini memisahkan rincian
pelaksanaan satu set objek dari penggunaan umum mereka.
Inti dari metode Pola Abstrak
adalah untuk “Menyediakan sebuah antarmuka untuk menciptakan keluarga obyek
terkait atau tergantung tanpa menentukan kelas beton mereka”.
Prinsip dasar dari Abstract
Factory pattern adalah:
1. Terdapat kelas Abstract
Factory (sebuah interface), dimana Abstract Factory merupakan sebuah interface
yang mendefinisikan bagaimana cara untuk, membuat objek dari Abstract Product.
Intent dari Abstract Factroy adalah menciptakan family dari objek yang berkaitan
tanpa harus bergantung pada concrete class-nya.
2. Terdapat kelas Concrete
Factory, dimana kelas ini akan mengimplementasikan semua metode pada
AbstractFactory untuk membuat objek dari concrete Product.
3. Terdapat kelas Abstract
Product, dimana kelas ini merupakan sebuah interface untuk mendefinisikan tipe
dari masing-masing objek produk.
4. Terdapat kelas Product,
merupakan kelas yang akan mengimplementasikan semua metode pada
AbstractProduct.
5. Terdapat Client, adalah
kelas yang akan terhubung dengan kelas Abstrac tFactory dan Abstract Product.
Berikut adalah contoh source
code program yang menggunakan abstract factory
using
System;
namespace
abstrakFactory
{
abstract
class Universitas
{
public
abstract Universitas_A Pake_Nama();
public
abstract Universitas_B Pake_Nick();
}
class
Universitas_Satu : Universitas
{
public
override Universitas_A Pake_Nama()
{
return
new Nama_RitaArisKurniasari();
}
public
override Universitas_B Pake_Nick();
{
return
new Nick_Rita();
}
}
class
Universitas_Dua : Universitas
{
public
override Universitas_A Pake_Nama()
{
return
new Nama_DiaWahyuningsih();
}
public
override Universitas_B Pake_Nick()
{
return
new Nick_Dia();
}
}
abstract
class Universitas_A {}
abstract
class Universitas_B
{
public
abstract void Interact(Universitas_A a);
}
class
Nama_RitaArisKurniasari : Universitas_A{}
class
Nick_Rita : Universitas_B
{
public
override void Interact(Universitas_A a)
{
Console.WriteLine();
Console.WriteLine("UNIVERSITAS
A");
Console.WriteLine("
"+this.GetType().Name);
Console.WriteLine("
&& ");
Console.WriteLine("
"+a.GetType().Name);
}
}
class
Nama_DiaWahyuningsih : Universitas_A{}
class
Nick_Dia : Universitas_B
{
public
override void Interact(Universitas_A a)
{
Console.WriteLine();
Console.WriteLine("UNIVERSITAS
B");
Console.WriteLine("
"+this.GetType().Name);
Console.WriteLine("
&& ");
Console.WriteLine("
"+a.GetType().Name);
}
}
class
Atas
{
private
Universitas_A Pake_Nama;
private
Universitas_B Pake_Nick;
public
Atas(Universitas aa)
{
Universitas_B
= aa.Pake_Nick();
Universitas_A
= aa.Pake_Nama();
}
public
void Eksekusi()
{
Universitas_B.Interact(Universitas_A);
}
}
class
Program
{
public
static void Main(string[] args)
{
Universitas
satu = new Universitas_Satu();
Atas
x1 = new Atas(satu);
x1.Eksekusi();
Universitas
dua = new Universitas_Dua();
Atas
x2 = new Atas(dua);
x2.Eksekusi();
Console.WriteLine();
Console.Write("Press
any key to continue . . . ");
Console.ReadKey(true);
}
}
}
Source :
https://www.academia.edu/912877/Design_Pattern_I
Komentar
Posting Komentar