Strategi Method Patern

Penerapan design pattern Strategy di Java

Strategy pattern (juga dikenal sebagai kebijakan pola) adalah pola desain perangkat lunak tertentu, dimana algoritma dapat dipilih saat runtime. Secara resmi berbicara, strategi pola mendefinisikan sebuah keluarga algoritma, merangkum masing-masing, dan membuat mereka saling dipertukarkan. Strategi ini memungkinkan algoritma yang bervariasi secara independen dari klien yang menggunakannya.[1]

Sebagai contoh, sebuah kelas yang melakukan validasi pada data yang masuk dapat menggunakan pola strategi untuk memilih algoritma validasi yang didasarkan pada jenis data, sumber data, pilihan pengguna, dan faktor-faktor lain yang membedakan, atau. Faktor-faktor ini tidak diketahui untuk setiap kasus sampai run-time, dan mungkin memerlukan validasi yang berbeda untuk dilakukan. Strategi validasi, dikemas secara terpisah dari objek memvalidasi, dapat digunakan oleh benda-benda lain memvalidasi dalam berbagai bidang sistem (atau bahkan berbagai sistem) tanpa duplikasi kode.

Persyaratan penting dalam bahasa pemrograman adalah kemampuan untuk menyimpan referensi untuk beberapa kode dalam struktur data dan mengambilnya. Ini dapat dicapai dengan mekanisme seperti pointer asli fungsi, fungsi kelas, kelas atau kelas contoh dalam berorientasi objek bahasa pemrograman, atau mengakses penyimpanan internal implementasi bahasa kode melalui refleksi.

Structure :

Contoh di Java

// The classes that implement a concrete strategy should implement this.
// The context class uses this to call the concrete strategy.
interface Strategy {
    int execute(int a, int b); 
}

// Implements the algorithm using the strategy interface
class ConcreteStrategyAdd implements Strategy {

    public int execute(int a, int b) {
        System.out.println("Called ConcreteStrategyAdd's execute()");
        return a + b;  // Do an addition with a and b
    }
}

class ConcreteStrategySubtract implements Strategy {

    public int execute(int a, int b) {
        System.out.println("Called ConcreteStrategySubtract's execute()");
        return a - b;  // Do a subtraction with a and b
    }
}

class ConcreteStrategyMultiply implements Strategy {

    public int execute(int a, int b) {
        System.out.println("Called ConcreteStrategyMultiply's execute()");
        return a * b;   // Do a multiplication with a and b
    }    
}

// Configured with a ConcreteStrategy object and maintains a reference to a Strategy object
class Context {

    private Strategy strategy;

    // Constructor
    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public int executeStrategy(int a, int b) {
        return strategy.execute(a, b);
    }
}

// Test application
class StrategyExample {

    public static void main(String[] args) {

        Context context;

        // Three contexts following different strategies
        context = new Context(new ConcreteStrategyAdd());
        int resultA = context.executeStrategy(3,4);

        context = new Context(new ConcreteStrategySubtract());
        int resultB = context.executeStrategy(3,4);

        context = new Context(new ConcreteStrategyMultiply());
        int resultC = context.executeStrategy(3,4);
    }
}