Skip to content
17 September 2010 / Jeffrey Hermanto Halimsetiawan

[Pola dan Arsitektur Perangkat Lunak] Strategy Pattern


Untuk memecahkan suatu masalah yang besar, ada baiknya apabila kita belajar dari best practice yang telah ada. Salah satu best practice yang ada dalam rekayasa perangkat lunak adalah penggunaan design pattern / pola-pola perancangan. Mungkin banyak di antara kita yang secara tidak sadar telah menggunakan pattern-pattern tersebut namun tidak mengetahui apakah nama pattern tersebut sehingga apabila hal ini akan menyulitkan untuk bekerja dalam sebuah tim. Dengan adanya definisi atau nama dari suatu pattern maka diskusi dalam sebuah tim untuk menentukan pattern apakah yang akan dipakai tentunya akan menjadi jauh lebih mudah.

Salah satu pattern yang sering dipakai adalah Strategy. Contoh permasalahan yang dihadapi adalah permasalahan ketika kita ingin membuat sebuah program yang mampu menggambar Lingkaran, Kotak dan Garis. Barangkali sebagian orang menggunakan pendekatan sebagai berikut:

Definisi enumerasi untuk lingkaran, kotak, dan garis:

public enum Shape
{
    Lingkaran,
    Kotak,
    Garis
}

Definisi sebuah method yang digunakan untuk menggambar bentuk tersebut:

public void Draw(Graphics g, Shape s)
{
    switch (s)
    {
        case Lingkaran:
            //gambar lingkaran pada Graphics g
            break;
        case Kotak:
            //gambar kotak pada Graphics g
            break;
        case Garis:
            //gambar garis pada Graphics g
            break;
    }
}

Panggil method Draw untuk menggambar bangunan yang diinginkan dengan meng-override method OnPaint(PaintEventArgs e) pada sebuah Windows Form

protected override void OnPaint(PaintEventArgs e)
{
    base.OnPaint(e);
    Draw(e.Graphics, Shape.Lingkaran);
    Draw(e.Graphics, Shape.Kotak);
}

Cara di atas memang tidak salah dengan pendekatan terstruktur, tetapi coba dibayangkan apabila program ingin ditambah dengan bentuk yang baru semisal Segitiga, tentunya harus menambah enumerasi dan case pada method Draw() yang pada akhirnya penambahan bentuk tersebut akan mempengaruhi reliability dari keseluruhan program.

Oleh karena itu, dibutuhkan adanya pattern Strategy dengan pendekatan berorientasi objek sebagai berikut:

  1. Kotak, Lingkaran dan Garis adalah sebuah Shape yang tentunya memiliki fungsi Draw() yang berbeda-beda. Oleh karena itu, diperlukan sebuah abstract class Shape dengan abstract method Draw(Graphics g)
  2. /// <summary>
    /// Author : Jeffrey Hermanto Halimsetiawan
    /// </summary>
    public abstract class Shape
    {
        public abstract void Draw(Graphics g);
    }
    
  3. Mendefinisikan sebuah class Lingkaran yang merupakan turunan dari Shape
  4. /// <summary>
    /// Author : Jeffrey Hermanto Halimsetiawan
    /// </summary>
    public class Lingkaran : Shape
    {
        private Point _pusat;
        private int _radius;
    
        public Point Pusat
        {
            get
            {
                return _pusat;
            }
            set
            {
                _pusat = value;
            }
        }
    
        public int Radius
        {
            get
            {
                return _radius;
            }
            set
            {
                _radius = value;
            }
        }
    
        public override void Draw(System.Drawing.Graphics g)
        {
            Pen pen = new Pen(new SolidBrush(Color.DarkGreen));
    
            g.DrawEllipse(pen, _pusat.X - _radius,
                               _pusat.Y - _radius,
                               _radius * 2,
                               _radius * 2);
        }
    }
    
  5. Mendefinisikan sebuah class Kotak yang merupakan turunan dari Shape
  6. /// <summary>
    /// Author : Jeffrey Hermanto Halimsetiawan
    /// </summary>
    public class Kotak : Shape
    {
        private Point _kiriAtas;
        private Point _kananBawah;
    
        public Point KananBawah
        {
            get
            {
                return _kananBawah;
            }
            set
            {
                _kananBawah = value;
            }
        }
    
        public Point KiriAtas
        {
            get
            {
                return _kiriAtas;
            }
            set
            {
                _kiriAtas = value;
            }
        }
    
        public override void Draw(System.Drawing.Graphics g)
        {
            Pen pen = new Pen(new SolidBrush(Color.Brown));
    
            g.DrawRectangle(pen, _kiriAtas.X,
                                 _kiriAtas.Y,
                                 _kananBawah.X - _kiriAtas.X,
                                 _kananBawah.Y - _kiriAtas.Y);
        }
    }
    
  7. Mendefinisikan sebuah class Garis yang merupakan turunan dari Shape
  8. /// <summary>
    /// Author : Jeffrey Hermanto Halimsetiawan
    /// </summary>
    public class Garis : Shape
    {
        private Point _titik1;
        private Point _titik2;
    
        public Point Titik1
        {
            get
            {
                return _titik1;
            }
            set
            {
                _titik1 = value;
            }
        }
    
        public Point Titik2
        {
            get
            {
                return _titik2;
            }
            set
            {
                _titik2 = value;
            }
        }
    
        public override void Draw(System.Drawing.Graphics g)
        {
            Pen pen = new Pen(new SolidBrush(Color.Magenta));
    
            g.DrawLine(pen, _titik1, _titik2);
        }
    }
    
  9. Definisikan sebuah UserControl bernama DrawCanvas sebagai tempat untuk menggambar berbagai jenis Shape
  10. /// <summary>
    /// Author : Jeffrey Hermanto Halimsetiawan
    /// </summary>
    public partial class DrawCanvas : UserControl
    {
        public DrawCanvas()
        {
            InitializeComponent();
        }
    }
    
  11. Definisikan private field bertipe List<Shape> pada DrawCanvas bernama _gambar
  12. private List<Shape> _gambar;
    
  13. Definisikan sebuah method InitializeShape() yang akan melakukan inisialisasi berbagai bentuk Shape
  14. private void InitializeShape()
    {
        Kotak k = new Kotak();
        k.KiriAtas = new Point(10, 10);
        k.KananBawah = new Point(110, 110);
        _gambar.Add(k);
    
        Lingkaran l = new Lingkaran();
        l.Pusat = new Point(60, 60);
        l.Radius = 30;
        _gambar.Add(l);
    
        Garis g = new Garis();
        g.Titik1 = new Point(81, 39);
        g.Titik2 = new Point(39, 81);
        _gambar.Add(g);
    }
    
  15. Panggil method InitializeShape() pada constructor DrawCanvas()
  16. public DrawCanvas()
    {
        _gambar = new List<Shape>();
    
        InitializeComponent();
    
        InitializeShape();
    }
    
  17. Override method OnPaint() pada DrawCanvas
  18. protected override void OnPaint(PaintEventArgs e)
    {
        base.OnPaint(e);
    
        foreach (Shape s in _gambar)
        {
            s.Draw(e.Graphics);
        }
    }
    
  19. Tambahkan UserControl DrawCanvas pada sebuah Windows Form

Secara umum, class diagram dari program ini adalah sebagai berikut:

Class Diagram Simple Strategy

Class Diagram Simple Strategy

Ketika dijalankan, program ini akan menampilkan output sebagai berikut:

Output Simple Strategy

Output Simple Strategy

Jadi, pada penggunaan pattern Strategy dapat dilihat bahwa jika ada penambahan Shape baru maka hanya perlu melakukan penambahan class semisal Segitiga yang merupakan turunan dari Shape. Tentunya penambahan class baru ini tidak berdampak pada reliability keseluruhan program karena bagian program yang reliability-nya masih rendah hanyalah pada class Segitiga tersebut. Selain itu, dengan adanya pemecahan menjadi class-class tersebut akan memudahkan untuk bekerja dalam sebuah tim dibandingkan dengan pendekatan terstruktur sebelumnya.

  1. jagadkomputer / Sep 20 2010 08:33

    artikelnya bagus2..maju terus pemrograman indonesia..o ya salam kenal, silakan berkunjung juga di tempat saya, terima kasih

    • Jeffrey Hermanto / Sep 20 2010 20:55

      o y, terima kasih..
      semoga dapat bermanfaat..
      salam kenal juga😀

  2. jagadkomputer / Sep 20 2010 13:20

    berkunjung lagi di siang hari yang lumayan panas…met knal aja..silakan mampir juga di tempat saya..thanks

  3. Bindus Abid / Jan 21 2011 10:46

    Bisakah lingkaran di dalamnya ada sudut yang membentuk arah mata angin?

    • Jeffrey Hermanto / Jan 24 2011 19:18

      Bisa saja asal telah didapatkan titik di garis lingkaran berdasarkan perhitungan sudut yang telah dilakukan. Kalau menggambarnya tinggal DrawLine biasa.

  4. Angga Ramadhan / Mar 15 2011 18:00

    sangat bagus artikel nya
    thank’s bsa belajar banyak program saya

    • Jeffrey Hermanto / Mar 15 2011 21:32

      terima kasih..
      semoga dapat bermanfaat😀

Trackbacks

  1. [Pola dan Arsitektur Perangkat Lunak] Composite Pattern « Tutorial Pemrograman Komputer Sederhana

Tinggalkan Balasan

Isikan data di bawah atau klik salah satu ikon untuk log in:

Logo WordPress.com

You are commenting using your WordPress.com account. Logout / Ubah )

Gambar Twitter

You are commenting using your Twitter account. Logout / Ubah )

Foto Facebook

You are commenting using your Facebook account. Logout / Ubah )

Foto Google+

You are commenting using your Google+ account. Logout / Ubah )

Connecting to %s

%d blogger menyukai ini: