9.1. State Pattern
State pattern merupakan salah
satu design pattern yang tergolong ke dalam behavioral pattern. State pattern
muncul akibat adanya kondisi-kondisi (states) yang muncul pada saat pembuatan
perangkat lunak. Pattern ini mengijinkan state transition logic untuk disatukan
dengan sebuah state object daripada berada dalam kondisional atau switch
statement. Pada tugas akhir kali ini, dibuat sebuah perangkat lunak yang
mengimplementasikan state pattern untuk menyelesaikan sebuah kasus yang
memiliki beberapa kondisi. Untuk mengevaluasi state pattern, dilakukan
pengujian serta perhitungan terhadap object-oriented metrics. Sedangkan untuk
mengetahui kelebihan dan kekurangan yang ada pada state pattern, akan
dibandingkan hasil perhitungan object-oriented metrics perangkat lunak yang menerapkan
state pattern dengan perangkat lunak yang tidak menerapkan state pattern untuk
sebuah kasus yang serupa. Berdasarkan hasil analisis dan pengujian, jika
dilihat dari perhitungan object-oriented metrics, perangkat lunak dengan state
pattern memiliki kompleksitas yang lebih tinggi dan membutuhkan usaha yang
lebih besar ketika dilakukan maintenance dibandingkan perangkat lunak tanpa
state pattern. Namun, jika dilihat dari penanggulangan state yang ada,
perangkat lunak dengan state pattern memiliki cara penanggulangan state yang
lebih optimal dibandingkan perangkat lunak tanpa state pattern.
Berikut ini contoh
Code State pattern dalam C#:
using System;
namespace
DoFactory.GangOfFour.State.Structural
{
class MainApp
{
static void
Main()
{
// Setup context in a state
Context c = new Context(new ConcreteStateA());
// Issue requests, which toggles state
c.Request();
c.Request();
c.Request();
c.Request();
// Wait for user
Console.ReadKey();
}
}
abstract class State
{
public abstract void Handle(Context
context);
}
class ConcreteStateA
: State
{
public override void Handle(Context
context)
{
context.State
= new ConcreteStateB();
}
}
class ConcreteStateB
: State
{
public override void Handle(Context
context)
{
context.State
= new ConcreteStateA();
}
}
class Context
{
private State
_state;
// Constructor
public Context(State
state)
{
this.State = state;
}
// Gets or sets the state
public State State
{
get { return _state;
}
set
{
_state
= value;
Console.WriteLine("State:
" +
_state.GetType().Name);
}
}
public void Request()
{
_state.Handle(this);
}
}
}
9.2. Strategy Pattern
Dalam
pemrograman komputer, strategi pattren adalah
desain pattren software tertentu, dimana algoritma dapat dipilih pada saat
runtime tergantung pada kondisi, seperti strategi dalam situasi perang.
Strategi pattern mendefinisikan keluarga algoritma, merangkum dan membuat
dipertukarkan. Membiarkan setiap algoritma bervariasi independen dari klien
yang menggunakannya, merangkum masing-masing sebagai obyek, dan membuat mereka
saling dipertukarkan. Strategi pattren memungkinkan algoritma
bervariasi independen dari klien yang menggunakannya. Strategi pattern
digunakan untuk membuat perubahan ini tidak mempengaruhi kode lain, sehingga
menghindari konsekuensi yang tidak diinginkan untuk kode kita dan menyediakan
fleksibilitas yang lebih besar. Tujuannya adalah
mendefiniskan suatu keluarga algoritma yang dipisahkan dari object yang asli
guna meningkatkan fleksibilitas dan reusability. Penerapan strategy pattern ini memungkinkan client
dapat menggunakan algoritma tersebut secara bergantian dengan bebas.
Berikut ini contoh
Code Strategy pattern dalam java:
using System;
namespace
DoFactory.GangOfFour.Strategy.Structural
{
class MainApp
{
static void Main()
{
Context context;
// Three contexts following different strategies
context
= new Context(new ConcreteStrategyA());
context.ContextInterface();
context
= new Context(new ConcreteStrategyB());
context.ContextInterface();
context
= new Context(new ConcreteStrategyC());
context.ContextInterface();
// Wait for user
Console.ReadKey();
}
}
abstract class Strategy
{
public abstract void AlgorithmInterface();
}
class ConcreteStrategyA
: Strategy
{
public override void AlgorithmInterface()
{
Console.WriteLine(
"Called ConcreteStrategyA.AlgorithmInterface()");
}
}
class ConcreteStrategyB
: Strategy
{
public override void AlgorithmInterface()
{
Console.WriteLine(
"Called ConcreteStrategyB.AlgorithmInterface()");
}
}
class ConcreteStrategyC
: Strategy
{
public override void AlgorithmInterface()
{
Console.WriteLine(
"Called ConcreteStrategyC.AlgorithmInterface()");
}
}
class Context
{
private Strategy
_strategy;
public Context(Strategy
strategy)
{
this._strategy = strategy;
}
public void
ContextInterface()
{
_strategy.AlgorithmInterface();
}
}
}
background blognya menggangu
BalasHapus