设计模式学习之路（一）——策略模式

策略模式（Strategy Pattern）

定义：定义了算法族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。

作用：用于算法之间的替换，或者功能的增加，而不会影响到其他地方。

简单举个例子，我们开发一款游戏如果有需要定义一个鸭子，会飞，会叫，那我们可能会觉得很简单，然后一开始定义就直接定义一个父类，再加一个子类实现，代码如下:

public abstract class Duck {

    protected abstract void fly();
    protected abstract void quack();
    }

子类实现：

public generalDuck extends Duck {
     protected abstract void fly(){
    System.out.println("fly with wings");
    }
    protected abstract void quack(){
    System.out.println("quacking");
    }
}

那么这个时候项目经理告诉你改需求了，又新创建了一个鸭子，它用使用火箭飞，不会叫，这个时候你又得重新创建一个类

public rocketlDuck extends Duck {
     protected abstract void fly(){
    System.out.println("fly with rocket...");
    }
    protected abstract void quack(){
    System.out.println("I can't quark);
    }
}

这个时候你会发现代码重用的效果根本就没有达到，而且如果鸭子又不想用火箭了改用飞机了或者突然不会飞了，或者其他方式时候，就得改源代码了，那么今天我们先解决这个代码重用且利于扩展的问题，这里就引出我们的策略设计模式了，那么重新定义该怎么定义呢，首先，我们把这些可变的飞行方式抽取出来，单独形成一个接口：

public interface FlyBehavior {
    public void fly();
}

其次，飞行方式我们单独实现飞行接口

public class FlyWithRocket implements FlyBehavior{

    @Override
    public void fly() {
        System.out.println("I can fly with rocket");

    }
}

public class FlyWithWings implements FlyBehavior{

    @Override
    public void fly() {
        System.out.println("I'm can fly with Wings");   
    }

}

那么我们在抽象一个共同的父类出来，定义一些每个鸭子共有的一些属性

public abstract class Duck {

    private FlyBehavior flyBehavior;//用于引用飞行实现类，实现多态变化
    private QuackBehavior quackBehavior;//暂时不用

    //用于设置飞行方式
    public void setFlyBehavior(FlyBehavior flyBehavior) {
        this.flyBehavior = flyBehavior;
    }

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

    public abstract void display(); 

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

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

    //假设每只鸭子一定会游泳
    public void swim(){
        System.out.println("All ducks can swim");
    }

}

这个时候，我们定义一个特殊鸭子继承鸭子

public class SpecialDuck extends Duck {

}

接着创建特殊鸭子，一开始用翅膀飞，接着改为用火箭

Duck duck  = new MSpecialDuck();
duck.setFlyBehavior(new FlyWithWings());
duck.performFly();//使用翅膀飞

duck.setFlyBehavior(new FlyWithSocket());
duck.performFly();//使用火箭飞

具体的UML图（摘自《headfirst设计模式》）：

这样即重用了代码，又降低了耦合。一举多得。
那么总结起来的话：
策略模式：建立行为族，将不同的行为分别封装，同时彼此可相互替代，算法的变化可以独立于使用者。
优点：提高了可复用性，将行为和使用者解耦出来
应用场景：
1、多个类只区别在表现行为不同，可以使用Strategy模式，在运行时动态选择具体要执行的行为。
2、 需要在不同情况下使用不同的策略(算法)，或者策略还可能在未来用其它方式来实现。(具体实现可任意变化或扩充)
3、 对客户隐藏具体策略(算法)的实现细节，彼此完全独立。