策略模式实现对数组的普通排序和特殊排序

策略模式实现对数组的普通排序和特殊排序 —> {1, 3, 7, 9, 8, 6, 2}

/**
 * 策略+工厂+模板
 * @Date: 2022/9/16  9:46
 * @Version 1.0
 * 策略模式实现对数组的普通排序和特殊排序  ————> {1, 3, 7, 9, 8, 6, 2}
 */
public class Test3 {
    public static void main(String[] args) {
        int[] arr = {1, 3, 2, 6, 7, 8, 9};
        int num = 0;
        Template template = new NormalSort();
        template.sort(arr, num);
    }

    //定义模板接口
    public interface Template {
        void sort(int[] arr, int num);
    }

    //模板实现类，定义具体的代码逻辑
    public static abstract class TemplateImplementation implements Template {
        @Override
        public void sort(int[] arr, int num) {
            //共有流程,排序
            CommonSort(arr);
            //特有逻辑，不同的排序策略
            doSpeciaThing(arr, num);
            //共有逻辑，打印
            CoownedPrint(arr);
        }

        //特有逻辑，不同的排序策略,给不出具体实现，定义出抽象方法
        protected abstract void doSpeciaThing(int[] arr, int num);

        //共有逻辑，打印
        protected void CoownedPrint(int[] arr) {
            System.out.println(Arrays.toString(arr));
        }

        //共有流程,排序
        protected void CommonSort(int[] arr) {
            Arrays.sort(arr);
        }
    }

    //排序策略的类 --->普通排序
    public static class NormalSort extends TemplateImplementation {
        @Override
        protected void doSpeciaThing(int[] arr, int num) {
            PolicyInterface policyInterface = SortStrategyFactory.getSortStrategy(num);
            policyInterface.SortMethod(arr);
        }
    }

//    public static class SpeciSort extends TemplateImplementation {
//        @Override
//        protected void doSpeciaThing(int[] arr, int num) {
//            PolicyInterface policyInterface = SortStrategyFactory.getSortStrategy(num);
//            policyInterface.SortMethod(arr);
//        }
//    }

    //策略模式接口
    public interface PolicyInterface {
        void SortMethod(int[] arr);
    }

    //策略1--->普通排序
    public static class CommonSortingStrategy implements PolicyInterface {
        @Override
        public void SortMethod(int[] arr) {
            //此处不需写逻辑，因为普通排序的逻辑在上面的共有流程已经实现
        }
    }

    //策略2--->特殊排序
    public static class SpecialSortingStrategy implements PolicyInterface {
        @Override
        public void SortMethod(int[] arr) {
            //定义新数组
            int[] arr2 = new int[arr.length];
            int startNum = 0;
            int endNum = arr2.length - 1;

            //遍历数组      //1,2,3,6,7,8,9
            for (int i = 0; i < arr.length; i++) {
                if (i % 2 == 0) {
                    arr2[startNum] = arr[i];
                    startNum++;
                } else {
                    arr2[endNum] = arr[i];
                    endNum--;
                }
            }
            for (int i = 0; i < arr2.length; i++) {
                arr[i] = arr2[i];
            }
        }
    }

    //策略工厂
    public static class SortStrategyFactory {
        public static PolicyInterface getSortStrategy(int num) {
            if (num == 0) {
                //普通排序
                return new CommonSortingStrategy();
            } else {
                //特殊排序
                return new SpecialSortingStrategy();
            }
        }
    }
}