策略模式

             策略模式              

 策略模式

---

策略模式：定义了算法族，分别封装起来，让他们之间可以相互替换，此模式让算法的变化独立于使用算法的客户。策略模式的重心不是如何实现算法，而是如何组织、调用这些算法，从而让程序结构更灵活，具有更好的维护性和扩展性。而对于在什么情况下使用什么算法，是由客户端决定的。

这个模式涉及到三个角色：
　● 环境(Context)角色：持有一个Strategy的引用。
　● 抽象策略(Strategy)角色：这是一个抽象角色，通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。（如果具体的策略类都有一些公共的行为，这时候应当把这些公有的行为放到共同的抽象策略角色类里面，当然这时候抽象策略角色必须要有抽象类实现，而不能使用接口。）
　● 具体策略(ConcreteStrategy)角色：包装了相关的算法或行为。

策略模式的缺点
     由于策略模式把每个具体的策略实现都单独封装成为类，如果备选的策略很多的话，那么对象的数目就会很可观。

设计原则

---

• 找出应用中可能变化的部分，把它们独立出来，不要和那些不需要变化的代码混在一起。
• 针对接口编程而不是针对实现编程
  变量的声明类型应该是超类，如此，只要具体实现此超类的所有对象，都可以指定给这个对象，这也意味着声明类不用理会以后执行时的真正的对象类型
• 多用组合少用继承
  可以在运行时动态的改变行为，只要组合的行为对象符合正确的标准接口即可

案例

---

Duck

public abstract class Duck {
    FlyBehavior flyBehavior;
    QuackBehavior quackBehavior;

    //多用组合少用继承
    public void setFlyBehavior(FlyBehavior fb) {
        flyBehavior = fb;
    }

    public void setQuackBehavior(QuackBehavior qb) {
        quackBehavior = qb;
    }

    public Duck() {
    }

    public abstract void display();

    //策略模式：让算法的变化独立于使用算法的客户
    public void performFly() {
        flyBehavior.fly();
    }

    public void performQuack() {
        quackBehavior.quack();
    }

    public void swim() {
        System.out.println("all ducks float,even decoys!");
    }
}

FlyBehavior

interface FlyBehavior {
    public void fly();
}

FlyWithWings

public class FlyWithWings implements FlyBehavior {

    @Override
    public void fly() {
        System.out.println("i'm flying");
    }

}

QuackBehavior

public interface QuackBehavior {
    public void quack();
}

FlyWithWings

public class FlyWithWings implements FlyBehavior {

    @Override
    public void fly() {
        System.out.println("i'm flying");
    }

}

ModelDuck

public class ModelDuck extends Duck {

    public ModelDuck(){
        flyBehavior = new FlyNoWay();
        quackBehavior = new Quack();
    }
    
    @Override
    public void display() {
       System.out.println("i'm model duck");
    }
}

FlyRocketPowered

public class FlyRocketPowered implements FlyBehavior {
    @Override
    public void fly() {
       System.out.println("i'm flying with a rocket!");
    }
}

MiniDuckSimulator

public class MiniDuckSimulator {
    public static void main(String[] args) {
        Duck model = new ModelDuck();
        model.performFly();
        model.setFlyBehavior(new FlyRocketPowered());
        model.performFly();
    }
}

 

 

jdk中策略模式的应用

class Dog{
    int size;
    int weight;
 
    public Dog(int s, int w){
        size = s;
        weight = w; 
    }
}
 
class DogSizeComparator implements Comparator<Dog>{
 
    @Override
    public int compare(Dog o1, Dog o2) {
        return o1.size - o2.size;
    }
}
 
class DogWeightComparator implements Comparator<Dog>{
 
    @Override
    public int compare(Dog o1, Dog o2) {
        return o1.weight - o2.weight;
    }
}
 
public class ArraySort {
 
    public static void main(String[] args) {
        Dog d1 = new Dog(2, 50);
        Dog d2 = new Dog(1, 30);
        Dog d3 = new Dog(3, 40);
 
        Dog[] dogArray = {d1, d2, d3};
        printDogs(dogArray);
 
        Arrays.sort(dogArray, new DogSizeComparator());    
        printDogs(dogArray);
 
        Arrays.sort(dogArray, new DogWeightComparator());    
        printDogs(dogArray);
    }
 
    public static void printDogs(Dog[] dogs){
        for(Dog d: dogs)
            System.out.print("size="+d.size + " weight=" + d.weight + " ");
 
        System.out.println();
    }
}

 

 

 

HeadFirst 第一章