设计模式-策略模式 Strategy

定义一组算法，将每一个算法都封装起来，而且使它们之间能够互换。策略模式使这些算法在客户端调用它们的时候可以互不影响地变化。（Java的TreeSet集合中，构造方法可传入具体的比较器对象以实现不一样的排序算法。就是利用的策略模式）策略模式的用意是针对一组算法，将每个算法封装到具备共同接口的独立的类中， 从而使得它们能够相互替换，使用策略模式能够把行为和环境分割开来。

角色

• 抽象策略角色：策略类，一般由一个接口或者抽象类实现。
• 具体策略角色：包装了相关的算法和行为。
• 环境角色：持有一个策略类的引用，最终给客户端调用的。经过环境角色指定策略。

场景假设

模 拟 鸭 子 游 戏 ：SimUDuck。游戏中会出现各类鸭子，一边游泳戏水，一边呱 呱叫。不一样的鸭子有不一样的行为，因此咱们能够把鸭子会不会飞，怎么飞的行为定义为抽象策略角色，鸭子叫行为也定义成一种策略，由于叫法不一样。

分开变与不变

把会变化的部分取出并封装起来，以便之后能够轻易地改动或扩充此部分，而不影响不须要变化的其余部分。 咱们先抽象一个Duck类，鸭子有 fly() 和 quack() ，可是会随着鸭子的不一样而改变，因此咱们要抽出来，将他们定义为变的部分涉及成策略，Duck 类持有对应策略的引用，经过组合的方式实现。

设计类图

最后咱们整合鸭子的行为，分别将鸭子的飞行与嘎嘎叫的动做 "委托"（delagate）别人处理，而不是定义在Duck类中。 咱们用两个类似的方法performFly()和performQuack()取代鸭子类中的fly()与quack()。

代码实现

定义 Duck 抽象类，全部的鸭子都继承。经过组合代理的模式实现飞行与嘎嘎叫的功能，持有策略类（飞行，呱呱叫）的引用。 提供set方法指定不一样的策略，而后经过 performFly 与 performQuack 委托对应的策略实现。

环境角色

public abstract class Duck {

    FlyBehavior flyBehavior;
    QuackBehavior quackBehavior;

    public void performFly() {
        flyBehavior.fly();
    }

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

    /** * 展现鸭子 */
    public abstract void display();


    public void setFlyBehavior(FlyBehavior flyBehavior) {
        this.flyBehavior = flyBehavior;
    }

    public void setQuackBehavior(QuackBehavior quackBehavior) {
        this.quackBehavior = quackBehavior;
    }
}

复制代码

定义野鸭子：会飞，呱呱叫。

public class MallardDuck extends Duck {
    @Override
    public void display() {
        System.out.println("我是一只野鸭子");
    }
}
复制代码

定义模型鸭子：不会飞也不会叫。

public class ModelDuck extends Duck {
    @Override
    public void display() {
        System.out.println("我是一只模型鸭子");
    }
}
复制代码

策略抽象角色 FlyBehavior 、QuackBehavior

叫声抽象策略

public interface QuackBehavior {
    void quack();
}
复制代码

飞行抽象策略

public interface FlyBehavior {
    void fly();
}
复制代码

策略具体角色

实现抽象策略，规定算法逻辑。

• 不会飞的策略

public class FlyNoWay implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("老司机带带我，我不会飞");
    }
}
复制代码

• 会飞的策略

public class FlyWithWings implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("我会飞行，一冲云霄");
    }
}
复制代码

• 叫声策略呱呱叫实现

public class Quack implements QuackBehavior {
    @Override
    public void quack() {
        System.out.println("呱呱叫");
    }
}
复制代码

• 叫声策略: 不会叫策略

public class MuteQuack implements QuackBehavior {
    @Override
    public void quack() {
        System.out.println("我不会叫");
    }
}
复制代码

生成不一样的鸭子

• 会叫的野鸭子

public class MallardDuck extends Duck {
    @Override
    public void display() {
        System.out.println("我是一只野鸭子");
    }
}
复制代码

• 不会叫的模型鸭子

public class ModelDuck extends Duck {
    @Override
    public void display() {
        System.out.println("我是一只模型鸭子");
    }
}
复制代码

定义显示屏展现鸭子

public class MiniDuckSimulator {
    public static void main(String[] args) {

        //定义不会叫不会飞的鸭子
        FlyBehavior flyBehavior = new FlyNoWay();
        QuackBehavior quackBehavior = new MuteQuack();
        Duck modelDuck = new ModelDuck();
        //这里咱们能够设置不一样的行为实现类就会执行不一样的策略
        modelDuck.setFlyBehavior(flyBehavior);
        modelDuck.setQuackBehavior(quackBehavior);

        modelDuck.display();
        modelDuck.performFly();
        modelDuck.performQuack();
        System.out.println("-------------------");

        // 定义会叫会飞的鸭子
        FlyBehavior flyWithWings = new FlyWithWings();
        QuackBehavior quack = new Quack();
        Duck mallardDuck = new MallardDuck();

        mallardDuck.setFlyBehavior(flyWithWings);
        mallardDuck.setQuackBehavior(quack);

        mallardDuck.display();
        mallardDuck.performFly();
        mallardDuck.performQuack();

    }
}
复制代码

其实就是将将不一样的算法抽象，经过上下文切换策略实现不一样行为。咱们是否是还可使用策略模式代替不少的if else 判断执行不一样的算逻辑？这里留给读者去发现使用场景。 关注公众号 JavaStorm 获取最新文章，不点个赞么？