常人能看懂的设计模式（一）策略模式

初衷：

最近一直在研究设计模式，主要以专研《Head First设计模式》以及看网上各路大神的见解。这边想用自己对于23种设计模式的理解，用一种非程序员都能理解的方式去介绍设计模式，毕竟我觉得设计模式是一种很好的处理问题的思想方法，不应该仅限于代码的实现。希望能够对于刚接触设计模式的小伙伴们有所帮助。当然有不对的地方，欢迎下方留言。一定及时修改。

策略模式实现：

让我们一起转动我们的脑瓜，逐个解决一下问题。

1. 第一步：我们先简单的描述三种动物
   
   一号动物，人称它为白鹭，有白色的羽毛，能够飞行，能发出叫声。
   
   二号动物，人称它为麻雀，有棕白色的羽毛，能够飞行，能发出叫声。
   
   三号动物，人称它为老鹰，有黑白色的羽毛，能够飞行，能发出叫声。
   ====================================================
   按照如上介绍，我们能明显感觉到很繁琐。这三种动物明显有共性，我们可以剥离出来，使得描述他们更为简单。
   常识里我们就已经这么做了其实。我们人类为像他们这样的动物，定义了一个类。称之为鸟类。
   鸟类有什么特点？简单来看：1.能够飞行 2.能发出叫声 3.有羽毛。
   这里我们可以思考为什么我们要定义一个鸟类？
   当然是为了简化描述。
   有了鸟类的定义，上面三种的描述我们就能简化：
   一号动物，是一种鸟，人称它为白鹭，有白色的羽毛。
   二号动物，是一种鸟，人称它为麻雀，有棕白色的羽毛。
   三号动物，是一种鸟，人称它为老鹰，有黑白色的羽毛。

2. 第二步：我们要让鸟会捕鱼。
   这里如果我们很简单的定义，我们可以定义我们的鸟类会捕鱼。这样三种鸟就都会捕鱼了。
   。。。
   但这明显不对呀！！麻雀怎么捕鱼。明显不合适。而且常识告诉我们肯定不是鸟类都会捕鱼的。
   那应该怎么办呢？？？
   难道我们只能自己去定义会捕鱼的鸟类捕鱼？并且捕的鱼还不一样。如下方：
   一号动物，是一种鸟，人称它为白鹭，有白色的羽毛，能捕河里的小鱼。
   二号动物，是一种鸟，人称它为麻雀，有棕白色的羽毛，不能捕鱼。
   三号动物，是一种鸟，人称它为老鹰，有黑白色的羽毛，能捕河里的大鱼。
   。。。
   这里我们只有三种鸟，看似写的很方便，但是我们要是有100万种鸟，难道每一个都这么写过去？？？
   哪怕是这辈子跟鸟过不去了。
   那应该怎么办呢？？？
   首先我们肯定确认一点，每个鸟肯定是去自己定义能不能捕鱼，捕什么样的鱼。所以100万种鸟的捕鱼写我们肯定是要写的，主要是有什么办法能让我们写的不那么累。
   这里提醒一下大家了，像白鹭一样能捕河里的小鱼的鸟是不是还有很多！！！
   所以我们可以
   把捕河里小鱼的这种能力定义为1级捕鱼。
   同理把不会捕鱼定义为0级捕鱼，
   把捕河里的大鱼的能力定义为2级捕鱼。
   然后我们在鸟类中定于一个概念就是捕鱼能了。这样其实我们每种鸟类都有捕鱼的能力了。只不过捕鱼的能力等级不一一样。
   像这样：
   鸟类：1.能够飞行 2.能发出叫声 3.有羽毛 4.捕鱼能力
   一号动物，是一种鸟，人称它为白鹭，有白色的羽毛，捕鱼等级：1级。
   二号动物，是一种鸟，人称它为麻雀，有棕白色的羽毛，捕鱼等级：0级。
   三号动物，是一种鸟，人称它为老鹰，有黑白色的羽毛，捕鱼等级：2级。
   ====================================================
   能明显看出简单了很多对吧。而且最主要是就算现在新增加其他种类的鸟，捕鱼等级这块你只需要去选择等级即可，万一没有怎么办，比如大鹏鸟，假设他能捕海里的大鱼。
   那我们只需要定义捕鱼等级3：能捕海里的大鱼。然后将大鹏的等级设计成3就行。
   再者当一直大鹏老了，只能捕河里的鱼了。我们也不用修改大量的原文，只需要将大鹏的捕鱼等级设为2就行了。

初步总结

策略模式主张的其实就是
“有一个”可能比“是一个”更好。
当我们以后试图是表达一个事物是什么的时候，去想想它有什么，用它有什么来定义他会更好，因为这个定义说不定别人也有，当你又要描述别人的时候就能直接用了，而不用再次去描述。

=接下来是程序猿时间=

看了上面的简单例子，我们现在就应该去试试代码如何实现了。
我给大家先一个思路架构，你们可以看着架构先写。然后再去看我给出的答案。希望对各位有帮助。
思路：

• 创新一个抽象父类鸟类，目前鸟类只定义了（会飞，会叫，有羽毛，名字）
• 创建三种鸟类子类，他们都继承了父类鸟类。不过羽毛以及名字不同。
• 然后我们需要让鸟能够捕鱼，如果你理解了我上面说的意思，你应该能明白，我们需要先定义一个捕鱼能力的接口
• 编写三种代表不同捕鱼能力的接口实现类
• 父类鸟类增加捕鱼能力（捕鱼的接口）。并且设置一个set方法，让子类能够去设置该接口到底是由哪个实现类来实现。
• 父类增加一个实现捕鱼的方法，来调用接口实现类的捕鱼能力。
• 每个子类鸟类，设置自己的捕鱼能力。
• 最后创建个测试类，去创建不同的鸟，展示它们的捕鱼能力
  =========================================================
  下面是步骤实现代码：
  1.创新一个抽象父类鸟类，目前只定义了会飞，会叫，有羽毛，名字

public abstract class Bird {
    String name ;
    String Wing ;
    void fly(){
        System.out.println("会飞");
    };
    void quack(){
        System.out.println("会叫");
    };

}

2、创建三种鸟类子类，他们都继承了父类鸟类。不过羽毛以及名字不同。

public class Egret extends Bird{
    String name= "白鹭";
    String Wing = "白色的羽毛";
}

public class Sparrow extends Bird{
    String name= "麻雀";
    String Wing = "棕白色的羽毛";
}

public class Eagle extends Bird{
    String name= "老鹰";
    String Wing = "黑白色的羽毛";
}

3、这时候可以建一个测试类test。看看我们写的对不对。

public class test {
    public static void main(String[] args) {
        Egret egret = new Egret();
        Eagle eagle = new Eagle();
        Sparrow sparrow = new Sparrow();
        //老鹰
        System.out.println(eagle.name);
        System.out.println(eagle.Wing);
        eagle.fly();
        eagle.quack();
        System.out.println("=========");

        //白鹭
        System.out.println(egret.name);
        System.out.println(egret.Wing);
        egret.fly();
        egret.quack();
        System.out.println("=========");

        //麻雀
        System.out.println(sparrow .name);
        System.out.println(sparrow .Wing);
        sparrow .fly();
        sparrow .quack();
        System.out.println("=========");

    }
}

输出结果：

老鹰
黑白色的羽毛
会飞
会叫
=========
白鹭
白色的羽毛
会飞
会叫
=========
麻雀
棕白色的羽毛
会飞
会叫
=========

可以看出没有问题。

4、定义一个捕鱼的接口

public interface Fishing {
    public void Fish();
}

5、编写三个接口的实现类，定义不同的捕鱼等级

public class FishingImpl_01 implements Fishing {
    @Override
    public void Fish() {
        System.out.println("0级捕鱼能力");
    }
}

public class FishingImpl_02 implements Fishing {
    @Override
    public void Fish() {
        System.out.println("1级捕鱼能力");
    }
}

public class FishingImpl_03 implements Fishing {
    @Override
    public void Fish() {
        System.out.println("2级捕鱼能力");
    }
}

6、修改父类鸟类，增加捕鱼能力（捕鱼的接口）。并且设置一个set方法，让子类能够去设置该接口到底是由哪个实现类来实现。增加一个实现捕鱼的方法，来调用接口实现类的捕鱼能力。

public abstract class Bird {
    String name ;
    String Wing ;
    void fly(){
        System.out.println("会飞");
    };
    void quack(){
        System.out.println("会叫");
    };
    //新增部分
    private Fishing fishing;
    void setFishingLEVEL(Fishing fishing){
        this.fishing = fishing;
    }
    void showFishingLEVEL(){
        fishing.Fish();
    }
}

7、每个子类鸟类，设置自己的捕鱼能力。并展示

public class test {
    public static void main(String[] args) {
        Egret egret = new Egret();
        Eagle eagle = new Eagle();
        Sparrow sparrow = new Sparrow();
        //老鹰
        System.out.println(eagle.name);
        System.out.println(eagle.Wing);
        eagle.fly();
        eagle.quack();
        System.out.println("=========");

        //白鹭
        System.out.println(egret.name);
        System.out.println(egret.Wing);
        egret.fly();
        egret.quack();
        System.out.println("=========");

        //麻雀
        System.out.println(sparrow .name);
        System.out.println(sparrow .Wing);
        sparrow .fly();
        sparrow .quack();
        System.out.println("=========");

        //每个鸟类增加捕鱼能力
        eagle.setFishingLEVEL(new FishingImpl_03());
        sparrow.setFishingLEVEL(new FishingImpl_01());
        egret.setFishingLEVEL(new FishingImpl_02());

        //展示
        System.out.print("老鹰的捕鱼能力：");
        eagle.showFishingLEVEL();
        System.out.print("麻雀的捕鱼能力：");
        sparrow.showFishingLEVEL();
        System.out.print("白鹭的捕鱼能力：");
        egret.showFishingLEVEL();

    }
}

结果：

老鹰的捕鱼能力：2级捕鱼能力
麻雀的捕鱼能力：0级捕鱼能力
白鹭的捕鱼能力：1级捕鱼能力

策略模式官方介绍

策略模式定义了算法族，把每一个算法分别封装起来, 并且使它们可相互替换。策略模式模式使得算法的变化可独立于使用它的客户。

最后总结

ok，策略模式基本的内容就是这些了。其实里面还有很多细节可以去深究。一些优缺点，暂时我还没有吃透，等我理解完毕再来完善分享。
后面大家可以想想怎么样给我们的各种鸟增加飞行时间能力，或者视野能力等等。方式方法跟这个是类似的。
如果你对于策略模式这块还有更加深刻的理解和见解。欢迎下方留言。相互学习，相互进步。