Sunday, 18 December 2016

EAS PPL - Arabic & Japanese Numeral Converter

Perancangan Perangkat Lunak Menggunakan Design Pattern - Interpreter
Arabic & Japanese Numeral Converter 

Disusun oleh:
1. Shafly Naufal Adianto (5114100114)
2. Rahmatin Nadia (5114100130)
3, Hariyoso Ario Bimo (5114100166)

1. Studi Kasus

Studi kasus yang kami kerjakan adalah Arabic & Japanese Numeral Converter. Jadi didalam studi kasus ini kami akan membuat sebuah program yang dapat menerjemahkan angka dalam bahasa arab/jepang ke angka desimal dan sebaliknya.

2. Design Pattern



Design Pattern yang kami gunakan adalah design pattern interpreter, dimana didalam design pattern ini terdapat:
- sebuah abstract class yang mendefinisikan sebuah "grammar rule" yang nantinya akan digunakan untuk menginterpretasi data.
- Sebuah class yang bernama context yang digunakan untuk menyimpan data input dan output
- Serta subclass yang meng-extend abstract class untuk menggunakan grammar rulenya, di class ini lah proses interpretasi dilakukan.

Kami menggunakan design pattern ini karena studi kasus yang kami gunakan memiliki karakteristik seperti yang dijelaskan pada design pattern, interpreter. dimana terdapat context/data yang akan di interpret , abstract expression dan terminal expressionnya. Dengan menggunakan pattern ini, maka dibuat class diagram seperti dibawah:



Disini kita membuat Class Context berisi angka jepang/arab yang akan di convert dan yang sudah diconvert. Kemudian class Expression (untuk bahasa jepang) dan Expression2 (untuk bahasa arab) kami berisi grammar rule dalam pengkonversian angka romawi, dimana didalamnya terdapat fungsi interpret yang mendefinisikan cara pengonversian angka tersebut ke desimal.

Dibawah ini terdapat sequence diagram untuk masing usecase

1. Konversi jepang ke desimal

2. konversi desimal ke jepang


3. konversi desimal ke arab

4. konversi arab ke desimal


Component Diagram & Deployment Diagram








3. Implementasi

Pertama kita akan membuat dulu Class bernama Context
Context.Java
public class Context
{
   private String input;
   private int input2;
   private int output;
   private String output2= "";

    public Context(String input)
    {
      this.input = input;
    }
    
     public Context(int input)
    {
      this.input2 = input;
    }

    public String getInput()
    {
      return input;
    }
    
      public int getInput2()
    {
      return input2;
    }
    
    public void setInput(String input)
    {
      this.input = input; 
    }    
    
        public void setInput2(int input)
    {
      this.input2 = input; 
    }  
    
    public int getOutput()
    {
      return output;
    }
    
     public String getOutput2()
    {
      return output2;
    }

    public void setOutput(int output)
    {
      this.output = output;
    }   
    
    public void setOutput2(String output)
    {
      this.output2 = output;
    }  
}


Di class ini akan disimpan input output serta method method untuk mengeset dan mengambil nilainya.


Kemudian kita buat abstract class sebagai baseclass dari interpreter-interpreter yang dibuat
Disini terdapat method utama bernama interpret, yang mendefinisikan "grammar rule" untuk interpreter lain

Expression.Java
public abstract class Expression
{
   public int angka;
   public String s ="";
   public void interpret(Context context,int bahasa)
    {
      int substring;
      if (context.getInput().length() == 0) 
        return;

      if (context.getInput().startsWith(nine(bahasa)))
      {
        context.setOutput(context.getOutput() + (9 * multiplier()));
        substring = nine(bahasa).length();
        context.setInput(context.getInput().substring(substring));
      }
      else if (context.getInput().startsWith(eight(bahasa)))
      {
        context.setOutput(context.getOutput() + (8 * multiplier()));
        substring = eight(bahasa).length();
        context.setInput(context.getInput().substring(substring));
      }
      else if (context.getInput().startsWith(seven(bahasa)))
      {
        context.setOutput(context.getOutput() + (7 * multiplier()));
        substring = seven(bahasa).length();
        context.setInput(context.getInput().substring(substring));
      }
      else if (context.getInput().startsWith(six(bahasa)))
      {
        context.setOutput(context.getOutput() + (6 * multiplier()));
        substring = six(bahasa).length();
        context.setInput(context.getInput().substring(substring));
      }
      else if (context.getInput().startsWith(five(bahasa)))
      {
        context.setOutput(context.getOutput() + (5 * multiplier()));
        substring = five(bahasa).length();
        context.setInput( context.getInput().substring(substring));
      }
      else if (context.getInput().startsWith(four(bahasa)))
      {
        context.setOutput(context.getOutput() + (4 * multiplier()));
        substring = four(bahasa).length();
        context.setInput(context.getInput().substring(substring));
      }
      else if (context.getInput().startsWith(three(bahasa)))
      {
        context.setOutput(context.getOutput() + (3 * multiplier()));
        substring = three(bahasa).length();
        context.setInput(context.getInput().substring(substring));
      }
      else if (context.getInput().startsWith(two(bahasa)))
      {
        context.setOutput(context.getOutput() + (2 * multiplier()));
        substring = two(bahasa).length();
        context.setInput(context.getInput().substring(substring));
      }
      else if (context.getInput().startsWith(one(bahasa)))
      {
        context.setOutput(context.getOutput() + (1 * multiplier()));
        substring = one(bahasa).length();
        context.setInput(context.getInput().substring(substring));
      }
    }
    
    public void interpret2(Context context,int bahasa)
    {
      if (context.getInput2()/ multiplier() > 0)
      {
        angka = context.getInput2() / multiplier();
        s= context.getOutput2();
        switch (angka)
        {

               
                case 1:
                    s = s.concat(one(bahasa));
                    context.setInput2(context.getInput2() - 1*multiplier());
                break;
                 case 2:
                    s = s.concat(two(bahasa));
                    context.setInput2(context.getInput2() - 2*multiplier());
                break;
                 case 3:
                    s = s.concat(three(bahasa));
                    context.setInput2(context.getInput2() - 3*multiplier());
                break;
                 case 4:
                    s = s.concat(four(bahasa));
                    context.setInput2(context.getInput2() - 4*multiplier());
                break;
                 case 5:
                    s = s.concat(five(bahasa));
                    context.setInput2(context.getInput2() - 5*multiplier());
                break;
                 case 6:
                    s = s.concat(six(bahasa));
                    context.setInput2(context.getInput2() - 6*multiplier());
                break;
                 case 7:
                    s = s.concat(seven(bahasa));
                    context.setInput2(context.getInput2() - 7*multiplier());
                break;
                 case 8:
                    s = s.concat(eight(bahasa));
                    context.setInput2(context.getInput2() - 8*multiplier());
                break;
                 case 9:
                    s = s.concat(nine(bahasa));
                    context.setInput2(context.getInput2() - 9*multiplier());
                break;


        }
       
          context.setOutput2(s);
      }
        
    }

    public abstract String one(int bahasa);
    public abstract String two(int bahasa);
    public abstract String three(int bahasa);
    public abstract String four(int bahasa);
    public abstract String five(int bahasa);
    public abstract String six(int bahasa);
    public abstract String seven(int bahasa);
    public abstract String eight(int bahasa);
    public abstract String nine(int bahasa);
    public abstract int multiplier();
}
Expression2,Java
public abstract class  Expression2
{
    

   public String s ="";
   public void interpret2(Context context){
     if (context.getInput().length() == 0) 
        return;
     else
     {
         String str = context.getInput();

         StringBuilder builder = new StringBuilder();
         for(int i =0; i < str.length(); ++i ) {
                builder.append((char)((int)str.charAt(i) + 48-unicode()));
            }
          s = builder.toString();
          int hasil = Integer.valueOf(s);
            //System.out.println(s);
           context.setOutput(hasil);
           context.setInput("");
     }
    }
    public void interpret(Context context){
            String str = String.valueOf(context.getInput2());

            StringBuilder builder = new StringBuilder();
            for(int i =0; i < str.length(); ++i ) {
                builder.append((char)((int)str.charAt(i) - 48+unicode()));
            }
            s = builder.toString();
            //System.out.println(s);
            context.setOutput2(s);
            context.setInput2(0);
          
       }
       
   public abstract int unicode();
}




Kemudian dibuat tiap tiap class yang mengextend interpreter utama


arabicExpression.Java
public class arabicExpression extends Expression2{    public int unicode()    {        return 1632;    }}


ThousandExpression.Java

public class ThousandExpression  extends Expression{

    public String one(int bahasa) {
        if (bahasa == 1) return "千";
        else return "k";
    }
    public String two(int bahasa) { 
        if (bahasa ==1 ) return "二千"; 
        else return "";
    }
    public String three(int bahasa) { 
        if (bahasa == 1)return "三千";
                else return "";
    }
    public String four(int bahasa){ 
        if(bahasa ==1) return "四千"; 
                else return "";
    }
    public String five(int bahasa){ 
        if (bahasa ==1)return "五千"; 
                else return "";
    }
    public String six(int bahasa) { 
        if (bahasa ==1) return "六千"; 
                else return "";
    }
    public String seven(int bahasa) { 
        if (bahasa==1)return "七千"; 
                else return "";
    }
    public String eight(int bahasa) { 
       if(bahasa==1)return "八千"; 
               else return "";
    }
    public String nine(int bahasa){ 
        if(bahasa==1) return "九千"; 
                else return "";
    }
    public int multiplier() { return 1000; }
}

HundredExpression.Java
public class HundredExpression extends Expression{
    public String one(int bahasa) { if (bahasa == 1)return "百";
            else return "";}
    public String two(int bahasa) { if (bahasa == 1)return "二百";
            else return "";}
    public String three(int bahasa) { if (bahasa == 1)return "三千";
            else return "";}
    public String four(int bahasa){ if (bahasa == 1)return "三百"; 
            else return "";}
    public String five(int bahasa){ if (bahasa == 1)return "五百";
            else return "";}
    public String six(int bahasa) { if (bahasa == 1)return "六百";
            else return "";}
    public String seven(int bahasa) { if (bahasa == 1)return "七百";
            else return "";}
    public String eight(int bahasa) { if (bahasa == 1)return "八百";
            else return "";}
    public String nine(int bahasa){ if (bahasa == 1)return "九百";
            else return "";}
    public  int multiplier() { return 100; }
}


TenExpression.Java
public class TenExpression  extends Expression{
     public String one(int bahasa) { 
         if (bahasa == 1)return "十";
         else return "";
            }
    public String two(int bahasa) {
        if (bahasa == 1)return "二十";
        else return "";
        }
    public String three(int bahasa) {
        if (bahasa == 1)return "三十";
            else return "";
        }
    public String four(int bahasa){
        if (bahasa == 1)return "四十";
            else return "";
        }
    public String five(int bahasa){ 
        if (bahasa == 1)return "五十";
            else return "";
        }
    public String six(int bahasa) {
        if (bahasa == 1) return "六十";
            else return "";
        }
    public String seven(int bahasa) { 
        if (bahasa == 1)return "七十";
            else return "";
        }
    public String eight(int bahasa) { 
        if (bahasa == 1)return "八十";
            else return "k";}
    public String nine(int bahasa){ if (bahasa == 1)return "九十"; 
            else return "k";}
    public int multiplier() { return 10; }
}


OneExpression.Java


public class OneExpression  extends Expression{
     public String one(int bahasa) {if (bahasa == 1)return "一"; 
                else return "";}
    public String two(int bahasa) { if (bahasa == 1)return "二";
            else return "";}
    public String three(int bahasa) { if (bahasa == 1)return "三";
            else return "";}
    public String four(int bahasa){ if (bahasa == 1)return "四";
            else return "";}
    public String five(int bahasa){ if (bahasa == 1)return "五";
            else return "";}
    public String six(int bahasa) { if (bahasa == 1)return "六";
            else return "";}
    public String seven(int bahasa) { if (bahasa == 1)return "七"; 
            else return "";}
    public String eight(int bahasa) { if (bahasa == 1)return "八";
            else return "";}
    public String nine(int bahasa){ if (bahasa == 1)return "九";
            else return "";}
    public int multiplier(){
        return 1;
    }






Di class class ini didefiniskan kembali abstract Method pada class Expression, gunanya class-class ini adalah untuk memberikan aturan sendiri setiap satuannya.

setelah itu buat main class untuk menjalankan semuanya
public class MainInterpreter
{
    /**
     * @param args
     */
    public static void main(String[] args) {
           Scanner scan = new Scanner(System.in);
          //String roman = "MCMXXVIII";
          int bahasa;
          int pilihan;
          System.out.println("Choose a language to convert: \n1.Japanese 2.Arabic");
          bahasa = scan.nextInt();
          if(bahasa == 2)
          {
             System.out.println("Choose a function: \n1.Arabic to Decimal 2.Decimal to Arabic");
             pilihan = scan.nextInt();
             if (pilihan == 2 ){
                 
                 System.out.println("Enter Decimal Number to be converted: ");
                 int angka = scan.nextInt();
                 Context context = new Context(angka);
             
                 Expression2 exp = (Expression2) new arabicExpression();
                 exp.interpret(context);
                 System.out.println(angka + " = " + (context.getOutput2()));
             }
             else
             {
                System.out.println("Enter Arabic Number to be converted: ");
                 String huruf = scan.next();
                 Context context = new Context(huruf);
             
                 Expression2 exp = (Expression2) new arabicExpression();
                 exp.interpret2(context);
                System.out.println(huruf + " = " + (context.getOutput()));
             }
              
             
            // exp.interpret(context);

          }
          else if (bahasa == 1){
              
               System.out.println("Choose a function: \n1.Japanese to Decimal 2.Decimal to Japanese");
               pilihan = scan.nextInt();
               if (pilihan == 1 )
               {
                   if (bahasa == 1){
                       System.out.println("Enter Japanese Number to be converted: ");
                   }
                   
                   
                    String huruf = scan.next();
                    Context context = new Context(huruf); 
                    

                      // Build the 'parse tree' 
                      ArrayList<Expression> tree = new ArrayList<Expression>();

                      tree.add(new ThousandExpression());
                      tree.add(new HundredExpression());
                      tree.add(new TenExpression());
                      tree.add(new OneExpression());
          
                  
            
                      // Interpret 
                      for (Iterator it = tree.iterator(); it.hasNext();)
                      {
                          Expression exp = (Expression)it.next();
                          exp.interpret(context,bahasa);
                      }
                    System.out.println( huruf + " = " + Integer.toString(context.getOutput()));
               }

               else{
                    System.out.println("Enter Decimal Number to be converted: ");
    
            
                      int angka = scan.nextInt();
                       if (angka > 9999){
                            System.out.println("input invalid , Enter a number under 10000 ");
                            return;
                        }
                      Context context = new Context(angka); 
                     
            
                      // Build the 'parse tree' 
                      ArrayList<Expression> tree = new ArrayList<Expression>();
                      tree.add(new ThousandExpression());
                      tree.add(new HundredExpression());
                      tree.add(new TenExpression());
                      tree.add(new OneExpression());
            
                      // Interpret 
                      for (Iterator it = tree.iterator(); it.hasNext();)
                      {
                          Expression exp = (Expression)it.next();
                          exp.interpret2(context, bahasa);
                      }
            
                      System.out.println( angka + " = " + context.getOutput2());
                }
               
            }
         
    }
}






Output:



Disusun oleh:
1. Shafly Naufal Adianto (5114100114)
2. Rahmatin Nadia (5114100130)
3, Hariyoso Ario Bimo (5114100166)


Referensi:

https://sourcemaking.com/design_patterns/interpreter
http://www.oodesign.com/interpreter-pattern.html
Posted by at No comments:

Sunday, 27 November 2016

DESIGN PATTERN : TEMPLATE METHOD DESIGN PATTERN

1. Definisi Template Method Design Pattern
Template Method adalah sebuah tipe design pattern dimana terdapat sebuah baseclass yang akan mendefinisikan kerangka algoritma/urutan method yang nantinya akan digunakan oleh subclass-subclassnya. Base class ini akan dijadikan sebagai template untuk subclassnya, dan subclass tersebut bisa me-redefine method method yang ada di baseclass tersebut sesuai dengan kegunaan subclass itu tersendirinya.

 2. Gambar Diagram

Dari gambar diatas dapat dijelaskan, jadi FrameworkClass adalah class yang akan digunakan sebagai baseclass dimana ApplicationClassOne dan ApplicationClassTwo adalah subclassnya. Kemudian didalam baseclass tersebut terdapat templateMethod(), yang didalamnya terdapat urutan pemanggilan method: 1.stepOne() 2.stepTwo() 3.stepThree() . Pada gambar diatas method stepTwo() pada gambar dijadikan sebagai placeholder, dimana definisi fungsi stepTwo itu akan di redefine pada class masing masing.

 3. Contoh Sedehana
Untuk menjelaskan penggunaaan template method, maka dibuat sebuah program sederhana untuk simulasi membangun sebuah bangunan.

 Pertama, dibuat sebuah baseclass bernama HouseTemplate.Java

package com.journaldev.design.template;

public abstract class HouseTemplate {

 //template method, final so subclasses can't override
 public final void buildHouse(){
  buildFoundation();
  buildPillars();
  buildWalls();
  buildWindows();
  System.out.println("House is built.");
 }

 //default implementation
 private void buildWindows() {
  System.out.println("Building Glass Windows");
 }

 //methods to be implemented by subclasses
 public abstract void buildWalls();
 public abstract void buildPillars();

 private void buildFoundation() {
  System.out.println("Building foundation with cement,iron rods and sand");
 }
}
Dari baseclass diatas dapat dilihat bahwa buildHouse dijadikan sebagai template method yang akan memangil buildFoundation buildPilars buildWalls dan buildWindows secara berurutan. Dimana function ini diberi final agar template method tidak dapat di override pada subclassnya. Fungsi yang terdapat didalam template method harus dapat di override agar subclass dapat meredefine isinya.

package com.journaldev.design.template;

public class GlassHouse extends HouseTemplate {

 @Override
 public void buildWalls() {
  System.out.println("Building Glass Walls");
 }

 @Override
 public void buildPillars() {
  System.out.println("Building Pillars with glass coating");
 }

}
Contoh diatas adalah subclass untuk membuat sebuah Glass House, dimana subclass ini meredefine isi dari buildWalls dan buildPillars. 

package com.journaldev.design.template;

public class WoodenHouse extends HouseTemplate {

 @Override
 public void buildWalls() {
  System.out.println("Building Wooden Walls");
 }

 @Override
 public void buildPillars() {
  System.out.println("Building Pillars with Wood coating");
 }

}
Contoh diatas ia membuat subclass untuk membuat WoodenHouse dimana dia mengoverride method buildWalls dan buildPillars.

package com.journaldev.design.template;

public class HousingClient {

 public static void main(String[] args) {
  
  HouseTemplate houseType = new WoodenHouse();
  
  //using template method
  houseType.buildHouse();
  System.out.println("************");
  
  houseType = new GlassHouse();
  
  houseType.buildHouse();
 }

}
Nah untuk menjalankan programnya , di main dapat dibuat baru , diatas diberikan contoh pertama kali ia membuat wooden house, maka akan digunakan method2 pada class WoodenHouse (yang telah sesuai pemanggilannya dengan template method). dan glass house akan mengugnakan method2 pada GlassHouse (yang juga telah sesuai pemanggilannya dengan template method).

 4. Output Implementasi:

Building foundation with cement,iron rods and sand
Building Pillars with Wood coating
Building Wooden Walls
Building Glass Windows
House is built.
************
Building foundation with cement,iron rods and sand
Building Pillars with glass coating
Building Glass Walls
Building Glass Windows
House is built.
5. Contoh Penggunaan:

 Contoh penggunaannya misalnya dalam pembuatan game yang didalamnya terdapat beberapa mini games, Misalnya, suatu game didalamnya terdapat permainan catur dan juga permainan monopoly, maka di baseclass game akan terdapat fungsi seperti inisialisasiGame, pergaintianPemain, akhirGame , printPemenang , dan  di subclass catur dan subclass monopoly , fungsi2 tersebut akan di redefine kembali lagi sesuai dengan aturan bermainnya. 

 Penjelasan implementasi contoh menggunakan pseudocode: 

abstract class Game {
    protected int playersCount;
    abstract void initializeGame();
    abstract void makePlay(int player);
    abstract boolean endOfGame();
    abstract void printWinner();

    /* A template method : */
    public final void playOneGame(int playersCount) {
        this.playersCount = playersCount;
        initializeGame();
        int j = 0;
        while (!endOfGame()) {
            makePlay(j);
            j = (j + 1) % playersCount;
        }
        printWinner();
    }
}


class Monopoly extends Game {

    void initializeGame() {
        // Initialize players
        // Initialize money
    }
    void makePlay(int player) {
        // Process one turn of player
    }
    boolean endOfGame() {
        // Return true if game is over 
        // according to Monopoly rules
    }
    void printWinner() {
        // Display who won
    }
    /* Specific declarations for the Monopoly game. */

    // ...
}

class Chess extends Game {

    void initializeGame() {
        // Initialize players
        // Put the pieces on the board
    }
    void makePlay(int player) {
        // Process a turn for the player
    }
    boolean endOfGame() {
        // Return true if in Checkmate or 
        // Stalemate has been reached
    }
    void printWinner() {
        // Display the winning player
    }
    /* Specific declarations for the chess game. */

    // ...
}
Posted by at No comments:
Subscribe to: Posts (Atom)