02_策略模式

策略模式的使用场景

• 多个类只有在算法或行为上稍微有不同的场景
• 算法需要自由切换的场景
• 需要屏蔽算法规则的场景

首先定义一个必须实现的compareable类

public interface compareable<T> {
    int compareTo(T o);
}

然后定义一个Dog类实现这个接口，实现compareTo方法

public class Dog implements Compareable<Dog> {
     
    int food;
 
    pubic Dog(int food) {
        this.food = food;
    }
 
    public int compareTo(Dog o) {
        if(this.food < o.food) return -1;
        else if(this.food > o.food) return 1;
        else return 0;
    }
 
}

在定义一个比较器，就可以使用了

public class Sorter {
     
public static void sort(Compareable[] arr) {
        for(int i = 0;i < arr.length - 1;i++) {
            int minPos= i;
            for(int j = i +1;j < arr.length;j++) {
                minPos = arr[j].compareTo(arr[minPos]) == -1 ? j : minPos;
            }
            swap(arr, i ,minPos);
        }
    }
 
    static void swap(Compareable[] arr, int i, int j) {
        Compareable temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

现在来正式说一下策略模式

策略模式总共分为三个角色：

Strategy抽象策略角色：

public interface Strategy {
    //策略模式的运算模式
    public void doSomething();
}

ConcreteStrategy具体策略角色：

public class ConcreteStrategy1 implements Strategy {
    public void doSomething() {
        System.out.println("具体策略1的运算法则");
    }
}
public class ConcreteStrategy2 implements Strategy {
    public void doSomething() {
        System.out.println("具体策略2的运算法则");
    }
}

Context封装角色：

public class Context {
    //抽象策略
    private Strategy strategy = null;
    //构造函数设置具体策略
    public Context(Strategy _strategy) {
        this.strategy = _strategy;
    }
    //封装后的策略方法
    public void doAnythinig() {
        this.strategy.doSomething();
    }
}

实现代码

public class Client {
    public static void main(String[] args) {
        //声明具体的策略
        Strategy strategy = new ConcreteStrategy1();
        //声明上下对象
        Context context = new Context(strategy);
        //执行封装后的方法
        context.doAnythinig();
    }
}