Kamis, 26 April 2012

Modul 4 - Structural Patterns (Decorator Pattern, Façade Pattern)


4.1. Decorator Patterns
                Maksud dari pola ini adalah dengan menambahkan tanggung jawab tambahan secara dinamis untuk objek. Memperluas fungsionalitas obyek bisa dilakukan secara statis (pada saat kompilasi) dengan menggunakan warisan namun mungkin diperlukan untuk memperluas fungsi suatu objek secara dinamis (saat runtime) sebagai objek yang digunakan. Pola dekorator berlaku ketika ada kebutuhan untuk secara dinamis menambahkan serta menghapus tanggung jawab ke kelas, dan ketika subclassing tidak mungkin karena jumlah besar dari subclass yang dapat terjadi. Tujuan dari decorator pattern adalah menciptakan suatu mata rantai objek,  dimana setiap objek mempunyai object responsible  pada fungsi objek berikutnya. Konteks dari pola ini adalah diinginkan untuk memperkaya behaviour dari suatu class, objek komponen  terdekorasi bisa digunakan sama seperti  objek komponen biasa, tanggung jawab dari proses dekorasi tidak diinginkan  ada pada class  komponen, kemungkinan ada proses dekorasi yang ditambahkan di masa depan yang tak bisa diperkirakan dan harus diantisipasi.
Tujuan Pattern ini adalah  menciptakan suatu mata rantai object, dimana setiap object mempunyai objects responsible pada fungsi objek berikutnya.( The  Decorator  attaches additional responsibilities to an object dynamically.)
Kelas peserta dalam pola dekorator adalah:
  1. Komponen - Interface untuk benda yang dapat memiliki tanggung jawab ditambahkan kepada mereka secara dinamis.
  2. ConcreteComponent - Mendefinisikan sebuah objek yang tanggung jawab tambahan dapat ditambahkan.
  3. Dekorator - Menjaga referensi ke objek Komponen dan mendefinisikan antarmuka yang sesuai dengan antarmuka Komponen ini.
  4. Dekorator Beton - Beton dekorator memperluas fungsionalitas komponen dengan menambahkan negara atau menambahkan perilaku.
Contoh Code dalam decorator pattern dalam java:
public class DecoratorBefore {
 
static class A { public void doIt() { System.out.print( 'A' ); } }
 
static class AwithX extends A {
   public  void doIt() { super.doIt();  doX(); }
   private void doX()  { System.out.print( 'X' ); }
}
 
static class AwithY extends A {
   public void doIt() { super.doIt();  doY(); }
   public void doY()  { System.out.print( 'Y' ); }
}
 
static class AwithZ extends A {
   public void doIt() { super.doIt();  doZ(); }
   public void doZ()  { System.out.print( 'Z' ); }
}
 
static class AwithXY extends AwithX {
   private AwithY obj = new AwithY();
   public void doIt() {
      super.doIt();
      obj.doY();
}  }
 
static class AwithXYZ extends AwithX {
   private AwithY obj1 = new AwithY();
   private AwithZ obj2 = new AwithZ();
   public void doIt() {
      super.doIt();
      obj1.doY();
      obj2.doZ();
}  }
 
public static void main( String[] args ) {
   A[] array = { new AwithX(), new AwithXY(), new AwithXYZ() };
   for (int i=0; i < array.length; i++) {
      array[i].doIt();
      System.out.print( "  " );
}  }  }
Hasil:


4.2. Façade Pattern
Menyediakan antarmuka yang seragam untuk satu set antarmuka dalam sebuah subsistem. Facade mendefinisikan antarmuka tingkat yang lebih tinggi yang membuat subsistem yang lebih mudah digunakan. Memungkus subsistem yang rumit dengan antarmuka sederhana. Masalah yang sering terjadi dalam pola ini adalah klien membutuhkan antarmuka yang disederhanakan untuk fungsi secara keseluruhan dari subsistem yang kompleks. Tujuan dari façade patterns adalah:
Ø  Mendefinisikan interface tingkatan yang lebih tinggi sehingga subsystem lebih mudah digunakan.
Ø  Menyediakan unifikasi interface  pada sekumpulan interface yang terdapat pada sebuah subsystem, dimana façade akan mendefiniskan interface tingkatan yang lebih tinggi sehingga subsystem lebih muda digunakan dengan menguraikan system kedalam subsystem untuk mengatasi kompleksitas sebuah system.
Contoh Façade pattern dalam Java:
// 1. Subsystem
class PointCarte {
  private double x, y;
  public PointCarte( double xx, double yy ) {
    x = xx;
    y = yy;
  }
  public void  move( int dx, int dy ) {
    x += dx;
    y += dy;
  }
  public String toString() {
    return "(" + x + "," + y + ")";
  }
  public double getX() {
    return x;
  }
  public double getY() {
    return y;
  } 
}
 
// 1. Subsystem
class PointPolar {
  private double radius, angle;
  public PointPolar( double r, double a ) {
    radius = r;
    angle = a;
  }
  public void  rotate( int ang ) {
    angle += ang % 360;
  }
  public String toString() {
    return "[" + radius + "@" + angle + "]";
  }
}
 
// 1. Desired interface: move(), rotate()
class Point {
  private PointCarte pc; // 2. Design a "wrapper" class
  
  public Point( double xx, double yy ) {
    pc = new PointCarte( xx,yy );
  }
  public String toString() {
    return pc.toString();
  }
  // 4. Wrapper maps
  public void move( int dx, int dy ) {
    pc.move( dx,dy );
  }
  public void rotate( int angle, Point o ) {
    double x = pc.getX() - o.pc.getX();
    double y = pc.getY() - o.pc.getY();
    PointPolar pp = new PointPolar( Math.sqrt(x*x+y*y),
                          Math.atan2(y,x)*180/Math.PI );
    // 4. Wrapper maps
    pp.rotate( angle );
    System.out.println( "  PointPolar is " + pp );
    String str = pp.toString();  int i = str.indexOf( '@' );
    double r = Double.parseDouble( str.substring(1,i) );
    double a = Double.parseDouble( str.substring(i+1,str.length()-1) );
    pc = new PointCarte(r*Math.cos(a*Math.PI/180) + o.pc.getX(),
                  r*Math.sin(a*Math.PI/180) + o.pc.getY() );
  }
}
 
class Line {
  private Point o, e;
  public Line( Point ori, Point end ) {
    o = ori;
    e = end;
  }
  public void  move( int dx, int dy ) {
    o.move( dx, dy );
    e.move( dx, dy );
  }
  public void  rotate( int angle ) {
    e.rotate( angle, o );
  }
  public String toString() {
    return "origin is " + o + ", end is " + e;
  }
}
 
class FacadeDemo {
  public static void main( String[] args ) {
    // 3. Client uses the Facade
    Line line1 = new Line( new Point(2,4), new Point(5,7) );
    line1.move(-2,-4);
    System.out.println( "after move:  " + line1 );
    line1.rotate(45);
    System.out.println( "after rotate: " + line1 );
    Line line2 = new Line( new Point(2,1), new Point(2.866,1.5) );
    line2.rotate(30);
    System.out.println( "30 degrees to 60 degrees: " + line2 );
  }
}
Hasil Compiling:

0 komentar:

Posting Komentar