最近看了《head first 设计模式》一书，便总结了里面的一些内容，今天就简单介绍一下策略模式。

策略模式：定义了算法族，分别封装起来，让他们能够相互替换，此模式让算法的变化独立于使用算法的客户。简单来说，就是将各个算法分别封装起来，使得他们能够互换。

下面是策略模式的示例结构图：

 

策略模式涉及三个角色：

• 环境类（context）：用一个ConcreteStrategy对象来配置。持有Strategy的引用。
• 抽象策略类（Strategy）：定义了所有算法的公共接口。
• 具体策略类（ConcreteStrategy）：定义了每一个算法，每个算法实现了同一个接口

源代码：

抽象策略类：

public interface Strategy {
    /**
     * 策略方法
     */
    public void strategyInterface();
}

 

 

具体策略类：

public class ConcreteStrategyA implements Strategy {

    @Override
    public void strategyInterface() {
        //相关的业务
    }

}

 

public class ConcreteStrategyB implements Strategy {

    @Override
    public void strategyInterface() {
        //相关的业务
    }

}

 

 

 

 

 

对象类：

public class Context {
    //持有一个具体策略的对象
    private Strategy strategy;
    /**
     * 构造函数，传入一个具体策略对象
     * @param strategy    具体策略对象
     */
    public Context(Strategy strategy){
        this.strategy = strategy;
    }
    /**
     * 策略方法
     */
    public void contextInterface(){
        
        strategy.strategyInterface();
    }
    
}

 

 

 

 

 

 

 

应用场景举例：

抽象策略类：

/**
 * @author haifei
 *    抽象策略类
 */
public interface FlyBehavior {
    public void fly();
}

 

具体策略类：

ConcreteStrategyA：

public class FlyNoWay implements FlyBehavior{

    @Override
    public void fly() {
        System.out.print("不会飞行");
    }

}

 

ConcreteStrategyB：

public class FlyWithWings implements FlyBehavior{

    @Override
    public void fly() {
        System.out.print("用翅膀飞行");
    }

}

 

环境类：

public class DuckSpecial {
    FlyBehavior flyBehavior;
    
    public DuckSpecial(FlyBehavior flyBehavior){
        this.flyBehavior = flyBehavior;
    }
    
    public void fly(){
        flyBehavior.fly();
    }
}

 

客户端：

public class DuckSpecialTest {
    
    public static void  main(String[] args) {
        //根据需要选择算法
        FlyBehavior fly = new FlyWithWings();
        DuckSpecial duck = new DuckSpecial(fly);
        duck.fly();
    }
}

 

运行结果：

用翅膀飞行