[디자인 패턴]Strategy 패턴

Strategy패턴 

스타크래프라는 게임을 보면 다양한 전술이 있다. 그리고 상대가 어떻게 행동 하느냐에 맞추어서 전술을 바꿔가면서 플레이 한다. 

Startegy패턴은 특정 알고리즘, 특정 로직등을 위임하여 통째로 바꾸기 쉽게 만들어주는 패턴입니다. 

저는 이번 예제에서 2개의 sortMachine을 만들고 한 곳은 quick 다른 한 곳은 merge를 사용하는 sort Machine을 만들어보겠습니다. 

파일 구조

SortStrategy 

public interface SortStrategy {
    public void sort(int[] arr);
}

//전략 인터페이스를 만듭니다. 이를 구현해주는 Quick과 Merge를 아래와 같이 만듭니다.

QuickSort

public class QuickSort implements SortStrategy {
    @Override
    public void sort(int[] arr) {
        quicksort(arr);
    }

    public void quicksort(int[] arr){
        quicksort(arr, 0, arr.length-1);
    }

    public void quicksort(int[] arr, int start, int end){
        int part = partition(arr, start, end);
        if(start < part-1)
            quicksort(arr, start, part-1);
        if(part < end)
            quicksort(arr, part, end);

    }

    public int partition(int[] arr, int start, int end){
        int pivot = arr[(start+end)/2];
        while(start <= end){
            while(arr[start] < pivot) start++;
            while(arr[end] > pivot)end--;
            if(start <= end){
                swap(arr, start, end);
                start++;
                end--;
            }
        }
        return start;
    }

    public void swap(int[] arr, int start, int end){
        int temp = arr[start];
        arr[start] = arr[end];
        arr[end] = temp;
    }
}

MergeSort

public class MergeSort implements SortStrategy {
    @Override
    public void sort(int[] arr) {
        mergesort(arr);
    }

    public void mergesort(int[] arr){
        mergesort(arr, 0, arr.length-1);
    }
    public void mergesort(int[] arr, int start, int end){
        if(start < end){
            int mid = (start+end)/2;
            mergesort(arr, start, mid);
            mergesort(arr, mid+1, end);
            merge(arr, start, mid, end);
        }
    }
    public void merge(int[] arr, int start, int mid, int end){
        int []temp = new int[end+1];
        int part1 = start;
        int part2 = mid+1;
        int index = start;

        for (int i = start; i <= end; i++)
            temp[i] = arr[i];

        while(part1 <= mid && part2 <= end){
            if(temp[part1] < temp[part2]){
                arr[index] = temp[part1];
                part1++;
            }else{
                arr[index] = temp[part2];
                part2++;
            }
            index++;
        }
        for(int i =0; i <=mid-part1; i++)
            arr[index+i] = temp[part1+i];
    }
}

SortMachine

public class SortMachine {
    private SortStrategy sortStrategy;
    private StringBuilder stringBuilder;
    public SortMachine(SortStrategy sortStrategy){
        this.sortStrategy = sortStrategy;
        this.stringBuilder = new StringBuilder();
    }
    public void sort(int arr[]){
        sortStrategy.sort(arr);
        save(arr);
    }

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

    private void save(int[] arr){
        for (int i1 : arr) stringBuilder.append(i1).append(" ");
    }

    public String toResult(){
        return stringBuilder.toString();
    }
}

//SortMachine에서는 Strategy를 위임받아서 sort를 실행해준다. 다른 Strategy를 가져다 주면 다른 Sort가 실행될 것입니다. 

//setSortStrategy을 통해 이미 Strategy가 등록되어 있어도 Strategy를 바꾸어 줄 수 있습니다. 

public class Main {
    public static void main(String[] args){
        int []arr1 = {5, 2,1, 3, 6, 4, 8, 0};
        int []arr2 = {5, 2,1, 3, 6, 4, 8, 0};

        SortMachine quicksortMachine = new SortMachine(new QuickSort());
        SortMachine mergesortMachine = new SortMachine(new MergeSort());

        quicksortMachine.sort(arr1);
        mergesortMachine.sort(arr2);

        System.out.println("quicksortMachine: " + quicksortMachine.toResult());
        System.out.println("mergesortMachine: " + mergesortMachine.toResult());
    }
}

//위임읕 통해서 Strategy를 전달해줄 수 있다.

위와 같이 재빨리 바꿀 수 있는 이유는 모두 위임 때문이다. 하위 클래스 Quick, Merge등이 상위 클래스 SortStrategy가 있음으로 쉽고 빠르게 바꿀 수 있습니다.  

결과