JAVA设计模式之策略模式

策略模式将可变的部分从程序中抽象分离成算法接口，在该接口下分别封装一系列算法实现，并使它们可以互相替换，从而导致客户端程序独立于算法的改变。

复合优先于继承，多用组合，少用继承

在类中增加一个私有域，引用另一个已有的类的实例，通过调用引用实例的方法从而获得新的功能，这种设计被称作组合。

组合：将飞行行为抽象为接口，在父类中持有该接口，并由该接口代替飞行行为

面向接口编程，而不是面向实现编程

多用组合，少用继承

策略模式的实现

1. 通过分离变化得出策略接口Strategy
2. Strategy的实现类
3. 客户程序有一个Strategy
4. 在客户程序中选择/组装正确的Strategy实现

策略模式优点

1. 使用了组合，是架构更加灵活
2. 富有弹性，可以较好的对应变化(开-闭原则)
3. 更好的代码复用性（相对于继承）
4. 消除大量的条件语句

策略模式缺点

1. 客户代码需要了解每个策略实现的细节
2. 增加了对象的数目

策略模式的适用场景

1. 许多相关的类仅仅是行为差异
2. 运行时选取不同的算法变体
3. 通过条件语句在多个分支中选取一

鸭子代码实现策略模式示例

/**
 * 超类，所有的鸭子都有继承此类
 * 抽象了鸭子的行为：显示和鸣叫
 * */
public abstract class Duck {
/*
 * 鸭子发出叫声
 * 通用行为，由超类实现
 * */
    public void quack(){
        System.out.println("嘎嘎。。。。");
    }
    /*
     * 显示鸭子的外观
     * 鸭子的外观各不相同，声明外abstract,由子类实现**/
    public abstract void display();
    
    /** 组合：将飞行行为抽象为接口，在父类中持有该接口，并由该接口代替飞行行为*/
    @SuppressWarnings("unused")
    private FlyingStragety flyingStragety;
    public void setFlyingStragety(FlyingStragety flyingStragety){
        this.flyingStragety = flyingStragety;
    }
    public void fly(){
        flyingStragety.performFly();
    }
}

/**
 * 策略接口，实现鸭子的飞行行为
 **/
public interface FlyingStragety {
    void performFly();
}

public class FlyWithRocket implements FlyingStragety{
    @Override
    public void performFly() {
        System.out.println("我用火箭飞行");
    }
}
public class FlyWithWin implements FlyingStragety{
    @Override
    public void performFly() {
        System.out.println("振翅高飞");    
    }
}
public class FlyNoWay implements FlyingStragety{
    @Override
    public void performFly() {
        System.out.println("我不会飞行");    
    }
}

public class MallardDuck extends Duck{
    public MallardDuck(){
        super();
        super.setFlyingStragety(new FlyWithWin());
    }
    @Override
    public void display() {
        System.out.println("我的脖子是绿色的");    
    }
}
public class RedheadDuck extends Duck{

    public RedheadDuck(){
        super();
        super.setFlyingStragety(new FlyWithWin());
    }
    @Override
    public void display() {
        System.out.println("我的头是红色的");    
    }
}
public class SpaceDuck extends Duck{
    public SpaceDuck(){
        super();
        super.setFlyingStragety(new FlyWithRocket());
    }
    @Override
    public void display() {
        System.out.println("我是太空鸭子");    
    }
    public void quack() {
        System.out.println("无线电通讯");
    }
}
public class RubberDuck extends Duck{
    public RubberDuck(){    
        super();//调用父类的构造函数
        super.setFlyingStragety(new FlyNoWay());
    }
    @Override
    public void display() {
        System.out.println("我的橡胶鸭子");    
    }
    public void quack() {
        System.out.println("瑟瑟。。。");
    }
}
public class BigYellowDuck extends Duck{
    public BigYellowDuck(){
        super();
        super.setFlyingStragety(new FlyNoWay());
    }
    @Override
    public void display() {
        System.out.println("我是大黄鸭子");    
    }
    public void quack() {
    }
}

public class Test {
    public static void main(String[] args) {
        Duck duck =null;
        duck = new MallardDuck();
        duck.display();
        duck.quack();
        duck.fly();
        System.out.println("**************");
        duck = new RedheadDuck();
        duck.display();
        duck.quack();
        duck.fly();
        System.out.println("*****************");
        duck = new RubberDuck();
        duck.display();
        duck.quack();
        duck.fly();
        System.out.println("*****************");
        duck = new BigYellowDuck();
        duck.display();
        duck.quack();
        duck.fly();
        System.out.println("*****************");
        duck = new SpaceDuck();
        duck.display();
        duck.quack();
        duck.fly();
    }
}