设计模式——策略模式

前言

很早就想系统学习一下设计模式，跟公司的大佬交流了下，知道了我现在手上这本书——《Head First设计模式》，在下班后就迫不及待开始翻书了。这是一本挺沙雕的书，跟我以前看的书很不一样，四个字形容——图文并茂。读起来一点都不枯燥，挺有意思的一本书。
我在看这本书的时候，看到了一些非常重要的话，对于我这样的Java初学者来说挺重要的。
设计原则一：找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。
设计原则二：针对接口编程，而不是针对实现编程（“针对接口编程"真正的意思是"针对超类型编程”）。
设计原则三：多用组合，少用继承。

介绍

本书的第一个设计模式就是策略模式，我以前都没有注意到这个设计模式。先看看这个模式定义：策略模式定义了算法族，分别封装起来，让他们之间可以相互替换，此模式让算法的变化独立于使用算法的客户。

在看之前记住一件事，程序在后面升级过程中的变化。

假如要做一套模拟鸭子的游戏，需要鸭子们在多种场景下活动。我们第一个想法就是写一个Duck超类，不同的鸭子去继承这个方法。
Version-1.0.0

public abstract class Duck {

    public void swimng(){
        System.out.println("swiming");
    }
    public abstract void quack(){
        System.out.println("GaGaGa!!!");
    }
    //鸭子的外观
    public abstract void diaplay();
}

通过继承Duck这个超类，不同外观的鸭子就可以实现飞行和鸣叫。

Version-1.1.0

所有的鸭子都会鸣叫和游泳，但是飞行不是所有的鸭子都会的技能，现在要求加入一些会飞行的鸭子。
在原先版本上进行修改的话，对超类Duck修改成：

public abstract class Duck {

    public void swimng() {
        System.out.println("swimng");
    }

    public abstract void quack() {
        System.out.println("GaGaGa!!!");
    }
    //添加飞行方法
    public abstract void fly();
    
    public abstract void diaplay();
}

对于会飞的鸭子，我们只需要覆写fly( )，对于不会飞的鸭子，不用实现其方法体。

Version-1.2.0
现在游戏进行大升级，要求加入洗澡玩的橡皮鸭。考虑下橡皮鸭的特性，橡皮鸭不会叫。如果你硬要说橡皮鸭被挤压的时候会叫，那我们就加入木头做的鸭子，这回总不会叫了。
现在思考超类Duck中的quack( )，里面已经写了方法体。要是还想继续用Duck这个超类，你可以将quack( )方法写成抽象方法，并在子类里面实现quack( )方法。如果前面写了很多鸭子了，工程量非常庞大，而且随着加入新鸭子的特性，任务量只会越来越夸张。
现在考虑使用接口的方法实现，将鸭子的swiming( )、display( )方法提取出来作为抽象类，Fly( )和quack( )方法抽出来作为接口，鸭子们只需继承超类Duck和实现需要的接口即可。

public abstract class Duck {
    public void swimng() {
        System.out.println("swimng");
    }
    public abstract void display();
}

public interface Flyable {

    void fly();
}

public interface Quakable {
    
    void quack();
}

思考？

子类实现接口中的方法时，出现了大量重复的方法。 可以通过什么样的方法，能提高代码的复用率。在上面的例子中，我们已经得出了一种办法，就是将不需要变化和易变的分开处理。现在可以回到介绍那块看下策略模式的定义。

策略模式

个人认为策略模式很重要的一点是多态。
首先，在Duck类中加入Quackable和Flyable这个两个接口的实例变量，子类就不需要实现接口中的方法，只需要调用setFlyable(Quackable quack)和setQuakable（Flyable fly）方法就可以调用对应的方法，这样就提高了代码的复用率。
代码：

public abstract class Duck {

    private Flyable flyable;
    private Quakable quakable;

    public void swimng() {
        System.out.println("swimng");
    }

    public abstract void display();

    public void fly() {
        flyable.fly();
    }

    public void quack() {
        quakable.quack();
    }
	//getter setter
}

public interface Flyable {

    void fly();
}
``

public interface Quakable {

void quack();

}
``

public class FlySnow implements Flyable {

    @Override
    public void fly() {
        System.out.println("Snow Fly");
    }
}

public interface Quakable {

    void quack();
}

public class FlySnow implements Flyable {

    @Override
    public void fly() {
        System.out.println("Snow Fly");
    }
}

public class GaGaGa implements Quakable {
    @Override
    public void quack() {
        System.out.println("GaGaGa!!!");
    }
}

public class NewDuck extends Duck {
    
    Flyable flyable = new FlySnow();
    Quakable quakable = new GaGaGa();

    public NewDuck() {
        this.setFlyable(flyable);
        this.setQuakable(quakable);
    }
    
    @Override
    public void display() {
        System.out.println("白色的鸭子");
    }

}

public class Main {
    public static void main(String[] args) {
        Duck duck = new NewDuck();
        duck.quack();
        duck.fly();
        duck.display();
        duck.swimng();
    }
}

这本书的第一个设计模式就算结束了，相信你们看到这里也觉得很迷糊，但是个人认为重要的是这个思想。通过多态的特性，在运行时才能知道调用是哪一个具体的行为。

内容肯定不止这些，等功力再次上升继续更新！