策略模式（新手推荐）

设计模式是个神奇的东西，用得好的话可以让你的代码结构清晰简洁，用得不好则会让结构更加复杂难懂，包括使用过度。下面我打算分好几部分介绍下自己所理解的设计模式。

最近在看一本关于设计模式的书《深入浅出设计模式》，觉得书中讲的很生动形象。我打算用自己的理解结合书中的例子，给大家简单解释一下，适合和我一样的新手，同时欢迎大神批评指正。首先从策略模式开始。下面大家来看一个例子：

现在有抽象父类People，里面有eat()和sleep()等共有的方法以及抽象方法show()。下面有三个子类man，woman以及child,在子类中我们实现对应的show()方法。似乎并没有什么问题，大家都很好。具体代码如下：

People

public abstract class People {

public void eat(){
    System.out.println("all people eat");
}

public void sleep(){
    System.out.println("all people sleep");
}

public abstract void show();
}

Man

public class Man extends People{

@Override
public void show() {

    System.out.println("I have short hair");
}
}

Woman

public class Woman extends People {

@Override
public void show() {

    System.out.println("I have long hair");
}
}

Child

public class Child extends People {

@Override
public void show() {
    System.out.println("I have less hair");
}
}

分析以上代码，我们将公有部分（eat和sleep）在抽象类People实现，show在具体子类中实现。（不要说我吃米饭，婴儿吃奶嘴，eat应该不同的，大家安静安静别吵，现在不是纠结这个的时候）只能说我这个例子举的不太恰当，因为实际需求中总有一部分是固定不变的，我们这一步的任务就是将固定不变的抽取出来父类中实现而已。

这个地方有个很重要的思想，就是面对一个系统或者说一个模块，我们将固定不变的部分与经常变化的部分区分开来，分别对待，小心产品经理。

假设我现在需求要变，要所有的人都有move()方法。你会怎么做？你肯定会说我们都是面向对象编程，很简单啊，直接在People中增加move()方法并实现，这种上课时老师一直讲的东西，继承。

可是你想过没有，这样做会不会有什么问题？

---

child婴儿是不会移动的（不要纠结说婴儿会爬之类的，我眼睛会干）。这时候你会发现如果我们在父类中实现，那么将影响整个子类，这对于子类较多的类来说，是灾难性的。你肯定就会说，我们在People中设计一个抽象方法move()，然后在子类中实现不可以吗？

当然可以，代码如下：

People

public abstract class People {

public void eat(){
    System.out.println("all people eat");
}

public void sleep(){
    System.out.println("all people sleep");
}

public abstract void show();
public abstract void move();
}

Man

public class Man extends People{

@Override
public void show() {

    System.out.println("I have short hair");
}

@Override
public void move() {
    System.out.println("on foot");
}
}

Woman

public class Woman extends People {

@Override
public void show() {

    System.out.println("I have long hair");
}

@Override
public void move() {
    System.out.println("on foot");
}
}

Child

public class Child extends People {

@Override
public void show() {
    System.out.println("I have less hair");
}

@Override
public void move() {
}
}

好了，实现完成。在child类中，move()中我们什么也不做。现在需求来了，我们有一类人懒人。虽然是个大老爷们，但是我不想动，我被床封印了。你会怎么做？重新创建一个LazyMan类继承People，然后实现move(),在move中什么也不做？

你会说怎么不可以？？？

child和LazyMan中代码代码重复，做到代码重用了吗？什么，实现为空也叫代码重复？

住口。在Man和Woman中move不是已经代码重复了吗？还敢嘴硬。少年还有什么可说的？？
你会说，看来不行啊，我们必须求助于其他办法了。对的，我们试试其他办法。

能不能用接口？然后创建多个接口的子类分别实现？

具体实现如下：

IMoveBehavior

public interface IMoveBehavior {

public void move();
}

MoveWithFoot

public class MoveWithFoot implements IMoveBehavior {

@Override
public void move() {

    System.out.println("on foot");
}
}

MoveNothing

public class MoveNothing implements IMoveBehavior{

@Override
public void move() {

    System.out.println("move? no");
}
}

来看看我们的People

public abstract class People {

IMoveBehavior moveBehavior;

public void eat(){
    System.out.println("all people eat");
}
public void sleep(){
    System.out.println("all people sleep");
}
public abstract void show();

public void moveBehave(){
    moveBehavior.move();
}
}

我们在创建IMoveBehavior对象的时候需要知道IMoveBehavior具体指向的是什么，所以我们在People子类的构造函数中来指定。代码如下：

Man

public class Man extends People implements IMoveBehavior{

public Man(IMoveBehavior moveBehavior){
    this.moveBehavior = moveBehavior;
} 
@Override
public void show() {

    System.out.println("I have short hair");
}

@Override
public void move() {
    System.out.println("on foot");
}
}

Woman和Child类似，不贴了。我们写个测试类StrategyTest，看我们的代码复用是否成功？

StrategyTest

public class StrategyTest {

public static void main(String[] args) {

    Man niceMan = new Man(new MoveNothing());
    niceMan.moveBehave();
}
}

运行结果如下：

如果是勤劳的人，那就 Man niceMan = new Man(new MoveWithFoot());

问题解决，那还有没有什么不妥的地方呢？

我们moveBehavior是在创建的时候进行绑定的，如果我想动态地更改moveBehavior呢？是不是就傻眼了？

于是我们有个接下来的方法：

People

public abstract class People {

IMoveBehavior moveBehavior;
public void setMoveBehavior(IMoveBehavior moveBehavior){
    this.moveBehavior = moveBehavior;
}
public void eat(){
    System.out.println("all people eat");
}
public void sleep(){
    System.out.println("all people sleep");
}
public abstract void show();

public void moveBehave(){
    moveBehavior.move();
}
}

其他类不变。我们将moveBehavior的设置方法暴露出去，可以进行动态设定。来验证一下：
public class StrategyTest {

public static void main(String[] args) {

    Man niceMan = new Man();
    //给我走
    niceMan.setMoveBehavior(new MoveWithFoot());
    niceMan.moveBehave();
    //不许动
    niceMan.setMoveBehavior(new MoveNothing());
    niceMan.moveBehave();
}
}

验证结果如下：

几经波折，终于搞好了。这就是策略模式，下面我们来看下较为正式的定义（严肃点，不许笑）。

策略模式：

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

最后说一个重要的点：我们之前那种做法都是通过继承，面向实现做的，虽然可以得到要求，但是代码复用性不高，如果子类多，那将是灾难。我们要面向接口编程。

原则：少用继承，多用组合。

拓展：

1. 假设需求又变了，需要给所有人加上wear(穿衣的方法)，但是每种人的穿衣风格不同。男的穿西装，女的穿裙子，小孩穿肚兜，甚至超人内裤外穿。好解决吗？
2. 需求又变了，要求move增加骑自行实现。创造出喜欢骑自行车穿裙子的女生，好解决吗？嘿嘿嘿

最后有必要说一下，我文中出现猥琐的语句只是为了提起大家的兴趣，给大家将知识留下深刻的印象，我本人很正直，不信看我眼睛说话。

大家下期见，拜拜！

我的Github： Github主页
我的博客：博客