Strategy pattern က behavioral design pattern တစ်ခုပါ။ Strategy Pattern အကြောင်းပြောရရင် ပြဿနာ တစ်ခု ကို ဖြေရှင်းဖို့ အတွက် နည်းလမ်း မျိုးစုံ ရှိပါတယ်။ အဲဒီ နည်းလမ်းထဲက ဘယ် နည်းလမ်း နဲ့ ရှင်းမလဲ ဆိုတာကို ပြောပြပေးလိုက်တာပါပဲ။

ဥပမာ Google Map မှာ Point A ကနေ Point B ကို သွားမယ်။ အဲဒီ အခါမှာ သွားဖို့ Strategy တွေက

1. ကား နဲ့ သွားမယ်
2. လမ်းလျှောက် သွားမယ်
3. bus နဲ့ သွားမယ်

ဆိုပြီး strategy ရှိလာပါတယ်။ Strategy ပေါ်မှာ မူတည်ပြီး Route ကို ဖန်တီး ပါတယ်။

Class Diagram ကို ကြည့်ရအောင်။

Java code ကို ကြည့်ရအောင်။

interface RouteStrategy {
    void calculateRoute(String startPoint, String endPoint);
}

// Concrete Strategy: Car
class CarRouteStrategy implements RouteStrategy {
    @Override
    public void calculateRoute(String startPoint, String endPoint) {
        System.out.println("Calculating car route from " + startPoint + " to " + endPoint);
        // Put the actual car routing logic here
    }
}

// Concrete Strategy: Bus
class BusRouteStrategy implements RouteStrategy {
    @Override
    public void calculateRoute(String startPoint, String endPoint) {
        System.out.println("Calculating bus route from " + startPoint + " to " + endPoint);
        // Put the actual bus routing logic here
    }
}

// Concrete Strategy: Walk
class WalkRouteStrategy implements RouteStrategy {
    @Override
    public void calculateRoute(String startPoint, String endPoint) {
        System.out.println("Calculating walking route from " + startPoint + " to " + endPoint);
        // Put the actual walking routing logic here
    }
}

// Context class
class NavigationContext {
    private RouteStrategy routeStrategy;

    public void setRouteStrategy(RouteStrategy routeStrategy) {
        this.routeStrategy = routeStrategy;
    }

    public void calculateRoute(String startPoint, String endPoint) {
        routeStrategy.calculateRoute(startPoint, endPoint);
    }
}

public class Main {
    public static void main(String[] args) {
        NavigationContext navigation = new NavigationContext();

        // Calculate the route by car
        navigation.setRouteStrategy(new CarRouteStrategy());
        navigation.calculateRoute("Home", "Office");

        // Calculate the route by bus
        navigation.setRouteStrategy(new BusRouteStrategy());
        navigation.calculateRoute("Home", "School");

        // Calculate the route by walking
        navigation.setRouteStrategy(new WalkRouteStrategy());
        navigation.calculateRoute("Park", "Market");
    }
}

Navigation က calculateRoute ပဲ ခေါ်လိုက်တာပါပဲ။ ဒါပေမယ့် assign လုပ်ထားသည့် strategy ပေါ်မှာ မူတည်ပြီး routing result က ပြောင်းသွားမှာပါ။ CarRouteStrategy သုံးမယ်ဆိုရင် CarRouteStrategy ထဲက calculateRoute နဲ့ အသုံးပြုသွားပါမယ်။

နောက်ထပ် ဥပမာ ပေးရရင် Product ကို sorting လုပ်မယ်ပေါ့။

Java code ကို ကြည့်ရအောင်။

// Strategy interface
interface SortStrategy {
    void sort(int[] array);
}

// Concrete Strategy: BubbleSort
class BubbleSort implements SortStrategy {
    @Override
    public void sort(int[] array) {
        // Put the actual BubbleSort logic here
        // ...
        System.out.println("BubbleSort applied.");
    }
}

// Concrete Strategy: QuickSort
class QuickSort implements SortStrategy {
    @Override
    public void sort(int[] array) {
        // Put the actual QuickSort logic here
        // ...
        System.out.println("QuickSort applied.");
    }
}

// Concrete Strategy: MergeSort
class MergeSort implements SortStrategy {
    @Override
    public void sort(int[] array) {
        // Put the actual MergeSort logic here
        // ...
        System.out.println("MergeSort applied.");
    }
}

// Context class
class Products {
    private int[] array;
    private SortStrategy sortStrategy;

    public Products(int[] array) {
        this.array = array;
    }

    public void setSortStrategy(SortStrategy sortStrategy) {
        this.sortStrategy = sortStrategy;
    }

    public void sort() {
        sortStrategy.sort(array);
    }

    public void display() {
        System.out.print("Sorted array: ");
        for (int num : array) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
}

public class Main {
    public static void main(String[] args) {
        int[] array = { 64, 34, 25, 12, 22, 11, 90 };

        Products products = new Products(array);

        // Sort using BubbleSort
        products.setSortStrategy(new BubbleSort());
        products.sort();
        products.display();

        // Sort using QuickSort
        products.setSortStrategy(new QuickSort());
        products.sort();
        products.display();

        // Sort using MergeSort
        products.setSortStrategy(new MergeSort());
        products.sort();
        products.display();
    }
}

Pros and Cons

ကောင်းတာတွေကတော့

Runtime မှာ သက်ဆိုင်ရာ algorithms ကို ပြောင်းလဲ အသုံးပြုနိုင်ပါတယ်။ ဥပမာ Bus Route, Car Route လိုမျိုးပေါ့။

Open/Closed Principle ကိုလည်း follow လုပ်ထားပါတယ်။

မကောင်းတာကတော့

Algorithm တွေ ပြောင်းဖို့ မလိုသည့် project တွေမှာ ဆိုရင် သုံးဖို့ မလိုအပ်ပါဘူး။