设计模式-2策略模式

策略模式：定义一系列的算法,把每一个算法封装起来, 并且使它们可相互替换
也是属于对象行为型设计模式，具有开闭原则,即对扩展开放,对修改关闭

应用场景： 如：商城支付，不同等级的会员优惠金额等等，
示例：动物比较大小

策略抽象接口

public interface AnimalCompare<T> {
    // 定义一个动物比较的抽象方法
    int compareTo(T t,T t2);
}

策略运行承载类： 这里我是随便用来一个冒泡算法实现的。

public class AnimalSort<T> {

    // 动物比较具体的实现
    public void bubblingSort(T[] arr,AnimalCompare<T> compare){
        for(int i = 0; i<arr.length;i++){
            for(int j=0;j < arr.length - i-1; j++){
                // 比较方式由对象提供
                if(compare.compareTo(arr[j],arr[j+1]) > 0){
                    T t = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = t;
                }
            }
        }
    }
}

dog实体

@Data
@ToString
@AllArgsConstructor
@NoArgsConstructor
public class Dog  {
    int food;
}

策略抽象接口实现类：dog的food 比较实现：通过 实现策略抽象接口，重写比较方式。

public class DogFoodCompare implements AnimalCompare<Dog> {
    // 动物的比较方式 狗的饭量比较
    @Override
    public int compareTo(Dog d, Dog d2) {
        if (d.food > d2.food) return 1;
        else if(d.food < d2.food) return -1;
        return 0;
    }
}

猫的实体：也可以同内部类实现，减少对类的创建。

@Data
@ToString
@AllArgsConstructor
@NoArgsConstructor
public class Cat {

    int height;

    int weight;

    // 内部类实现策略
    public class CatWeightCompare2 implements AnimalCompare<Cat>{
        // 动物的比较方式 猫的重量比较
        @Override
        public int compareTo(Cat c, Cat c2) {
            if (c.weight  < c2.weight) return 1;
            else if(c.weight > c2.weight) return -1;
            return 0;
        }
    }

}

策略抽象接口实现类：cat 的height实现比较

public class CatHeightCompare implements AnimalCompare<Cat> {

    // 动物的比较方式 猫的高度比较
    @Override
    public int compareTo(Cat c, Cat c2) {
        if (c.height > c2.height) return 1;
        else if(c.height < c2.height) return -1;
        return 0;
    }
}

执行：

public class AnimalMain {

    /**
     * 策略模式（Strategy）属于对象行为型设计模式
     * 具有开闭原则,即对扩展开放,对修改关闭
     * @param args
     */

    public static void main(String[] args) {
        Dog[] dog = {new Dog(1),new Dog(7),new Dog(3)};
        Cat[] cats = {new Cat(2,2),new Cat(9,9),new Cat(5,5)};

        AnimalSort<Dog> animalSortDog = new AnimalSort<>();
        animalSortDog.bubblingSort(dog,new DogFoodCompare());
        System.out.println("狗的饭量升序"+Arrays.toString(dog));

        AnimalSort<Cat> animalSortCat = new AnimalSort<>();
        animalSortCat.bubblingSort(cats,new CatHeightCompare());
        System.out.println("猫的身高升序" + Arrays.toString(cats));
        // 调用内部类实现
        Cat cat = new Cat();
        Cat.CatWeightCompare2 catWeightCompare2 = cat.new CatWeightCompare2();

        animalSortCat.bubblingSort(cats,catWeightCompare2);
        System.out.println("猫的体重降序" +Arrays.toString(cats));
    }
}

执行结果：