《读_Head_First_有感》_“前言兼策略模式”

前言：
看到大佬们在做系列文章，我也尝试在提升自我的同时分享一下系列文章。
大学时，老师说到：“思想很重要，学会设计模式的使用就厉害了”，我那时其实不喜欢看书，怀着打游戏模式（特别想看到最终点），
我便读了大学唯一读过的一本课外书：设计模式（Java版），那时只是娱乐，现在是提升。
那第一本系列就《Head_First设计模式》这本书了！

1.官方话语

概述

设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。

六大原则：

单一职责原则 （Single ResponsiBility Principle） 概括：应该有且仅有一个原因引起类的变更
里氏替换原则（liskov Substitution Principle ） 概括：基类出现的地方，子类一定可以出现
依赖倒转原则（Depndece Inversion Principle） 概括：针对接口编程，依赖于抽象而不是具体
接口隔离原则（Interface Segregation Principle） 概括：使用多个隔离的接口，比使用单个接口好 （细分接口，降低耦合）
迪米特法则 (Demeter Principle) 概括：实体应当尽量少的与其他类发生互相作用，使得系统功能模块相对独立
开闭原则（Open Close Principle） 概括： 对扩展开放，对修改关闭
合成复用原则 （Composite Reuse Principle） 概括：尽量使用合成/聚合的方式，少用继承

个人话语

概述

设计模式在代码层级中，是让你在某种业务场景刚开始设计时，能让未来的相关需求扩展极为方便的一个思想。
简单的说，在一开始设计好，扩展是很方便的，设计模式就是这个功劳者。
对于我们本来就懒的开发人员来说，这是求之不得的。

六大原则

而对于六大原则，简单过一下就行，不用刻意理解，如果你会了面向对象和设计模式的使用，自然就遵循了。

今日主题

策略模式： 定义一组算法，将每个算法封装起来，并且使它们之间可以相互转换,此模式让算法的变化独立于使用算法的客户。

（business）

概述

鸭子类别，有两种鸭子（红头，绿头）有两个行为，一个相同共性（模拟每只鸭游泳形式是不变化的），不同共性（模拟每只鸭的外表行为是不一样的，但一般不会变化，一次性即可）

代码如下：

 1package top.huey.designpattern.strategypattern.business;
 2
 3/**
 4 * @author huey
 5 * @Description : 鸭子超类
 6 * @Date Created in 2018/7/3 15:55
 7 */
 8public abstract class Duck {
 9
10
11    /**
12     * 相同共性（模拟每只鸭游泳形式是不变化的）
13     */
14    public void swim() {
15        System.out.println("所有鸭子都是一样的游泳");
16    }
17
18    /**
19     * 不同共性（模拟每只鸭的外表行为是不一样的，但一般不会变化，一次性即可）
20     */
21    public abstract void display();
22
23}
24
25package top.huey.designpattern.strategypattern.business;
26/**
27 * @author huey
28 * @Description : 红头鸭
29 * @Date Created in 2018/7/3 15:56
30 */
31public class RedHeadDuck extends Duck {
32
33    @Override
34    public void display() {
35        System.out.println(this.getClass().toString() + "----------》display");
36    }
37
38}
39
40/**
41 * @author huey
42 * @Description : 绿头鸭
43 * @Date Created in 2018/7/3 15:54
44 */
45public class MallardDuck extends Duck {
46
47    @Override
48    public void display() {
49        System.out.println(this.getClass().toString() + "----------》display");
50    }
51
52
53}
54
55/**
56 * @author huey
57 * @Description : 测试demo
58 * @Date Created in 2018/7/3 17:31
59 */
60public class BusinessDemo {
61
62    @Test
63    public void test1() {
64        Duck mallardDuck = new MallardDuck();
65        Duck redDuck = new RedHeadDuck();
66        mallardDuck.display();
67        mallardDuck.swim();
68        redDuck.display();
69        redDuck.swim();
70    }
71
72}

总结：面向对象的基础设计。

（snapshot1）

概述：业务发生变化，现在需要增加个种类的“橡皮鸭”，多个“飞”的行为。而这个飞的行为是各种鸭子各种姿势飞，

代码如下：

  1package top.huey.designpattern.strategypattern.snapshot1;
  2
  3/**
  4 * @author huey
  5 * @Description : 鸭子超类
  6 * @Date Created in 2018/7/3 15:55
  7 */
  8public abstract class Duck {
  9
 10    /**
 11     * 相同共性（模拟每只鸭游泳形式是不变化的）
 12     */
 13    public void swim() {
 14        System.out.println("所有鸭子都是一样的游泳");
 15    }
 16
 17    /**
 18     * 不同共性（模拟每只鸭的外表行为是不一样的，但一般不会变化，一次性即可）
 19     */
 20    public abstract void display();
 21
 22    /**
 23     * 独立（模拟每只鸭经常变化的行为，一只鸭可能各种姿势飞。。。这个方法是经常变的，所以一旦更改，相关子类都得改）
 24     */
 25    public abstract void fly();
 26
 27}
 28
 29/**
 30 * @author huey
 31 * @Description : 绿头鸭
 32 * @Date Created in 2018/7/3 15:54
 33 */
 34public class MallardDuck extends Duck {
 35
 36    @Override
 37    public void display() {
 38        System.out.println(this.getClass().toString() + "----------》display");
 39    }
 40
 41    @Override
 42    public void fly() {
 43        System.out.println(this.getClass().toString() + "----------》 can fly");
 44    }
 45}
 46
 47/**
 48 * @author huey
 49 * @Description : 红头鸭
 50 * @Date Created in 2018/7/3 15:56
 51 */
 52public class RedHeadDuck extends Duck {
 53
 54    @Override
 55    public void display() {
 56        System.out.println(this.getClass().toString() + "----------》display");
 57    }
 58
 59    @Override
 60    public void fly() {
 61        System.out.println(this.getClass().toString() + "----------》 can fly");
 62    }
 63}
 64
 65
 66/**
 67 * @author huey
 68 * @Description : 橡皮鸭
 69 * @Date Created in 2018/7/3 17:57
 70 */
 71public class XiangPiDuck extends Duck {
 72    @Override
 73    public void display() {
 74        System.out.println(this.getClass().toString() + "----------》display");
 75    }
 76
 77    @Override
 78    public void fly() {
 79        System.out.println(this.getClass().toString() + "----------》 can't fly");
 80    }
 81}
 82
 83
 84/**
 85 * @author huey
 86 * @Description : 测试demo
 87 * @Date Created in 2018/7/3 17:31
 88 */
 89public class Snapshot1Demo {
 90
 91    @Test
 92    public void test1(){
 93       Duck mallardDuck = new MallardDuck();
 94       Duck redDuck = new RedHeadDuck();
 95       Duck xiangDuck = new XiangPiDuck();
 96       redDuck.fly();
 97       xiangDuck.fly();
 98       mallardDuck.display();
 99       mallardDuck.swim();
100       redDuck.display();
101       redDuck.swim();
102    }
103
104}

总结：

应该把经常变化的东西抽象出去，就不用改变所有子类duck了。如果按照这样继承，重写，那需求更改扩展时，需要更改所有相关子
duck，用继承实现了复用，但是重复代码很多。自然的联想到了，也就是快照2版本，面向接口编程

(snapshot2）

概述：把经常变化的东西抽象出去，即把飞行抽象成接口，让相关具备飞行行为的子类duck去实现这个接口

代码如下：

 1package top.huey.designpattern.strategypattern.snapshot2;
 2
 3/**
 4 * @author huey
 5 * @Description : 鸭子超类
 6 * @Date Created in 2018/7/3 15:55
 7 */
 8public abstract class Duck {
 9
10    /**
11     * 相同共性（模拟每只鸭游泳形式是不变化的）
12     */
13    public void swim() {
14        System.out.println("所有鸭子都是一样的游泳");
15    }
16
17    /**
18     * 不同共性（模拟每只鸭的外表行为是不一样的，但一般不会变化，一次性即可）
19     */
20    public abstract void display();
21
22}
23
24/**
25 * @author huey
26 * @Description : 绿头鸭
27 * @Date Created in 2018/7/3 15:54
28 */
29public class MallardDuck extends Duck implements FlyAble {
30
31
32    @Override
33    public void display() {
34        System.out.println(this.getClass().toString() + "----------》display");
35    }
36
37
38    /**
39     * 独立（模拟每只鸭经常变化的行为，一只鸭可能各种姿势飞。。。）
40     * 此时只是一个绿头鸭重写，如果100个子类的话，需要100个implement FlyAble
41     */
42    @Override
43    public void fly() {
44        System.out.println(this.getClass().toString() + "fly");
45    }
46}
47
48
49/**
50 * @author huey
51 * @Description : 橡皮鸭
52 * @Date Created in 2018/7/3 17:57
53 */
54public class XiangPiDuck extends Duck {
55
56    @Override
57    public void display() {
58        System.out.println(this.getClass().toString() + "----------》display");
59    }
60
61
62}
63
64/**
65 * @author huey
66 * @Description : 飞行行为（策略化）
67 * @Date Created in 2018/7/3 18:19
68 */
69public interface FlyAble {
70
71    /**
72     * 独立（模拟每只鸭经常变化的行为，一只鸭可能各种姿势飞。。。）
73     */
74    public void fly();
75}
76
77/**
78 * @author huey
79 * @Description : 测试demo
80 * @Date Created in 2018/7/3 17:31
81 */
82public class Snapshot2Demo {
83
84    @Test
85    public void test1() {
86        MallardDuck duck = new MallardDuck();
87        duck.fly();
88        XiangPiDuck xiangPiDuck = new XiangPiDuck();
89        //xiangPiDuck.fly(); 不会飞（没有实现FlyAble接口）
90    }
91
92}

总结

可能你发现这个快照2版本不存在太大问题，扩展时只要重新fly方法就行了，但是如果鸭子的类型有1000种，此时
你就要重写1000次飞的行为，即使存在相同飞的行为也要copy过去。

(zzrelease)

概述

经常变的飞行行为接口化，然后实现出具体的飞行行为，用组合模式和具体行为产生关联，并委托该行为执行具体的实现行为。
代码如下：

  1package top.huey.designpattern.strategypattern.zzrelease;
  2
  3import top.huey.designpattern.strategypattern.zzrelease.behavior.FlyBehavior;
  4
  5/**
  6 * @author huey
  7 * @Description : 鸭子超类
  8 * @Date Created in 2018/7/3 15:55
  9 */
 10public abstract class Duck {
 11
 12    private FlyBehavior flyBehavior;
 13
 14    public Duck(FlyBehavior flyBehavior) {
 15        this.flyBehavior = flyBehavior;
 16    }
 17
 18    public Duck() {
 19    }
 20
 21    /**
 22     * 相同共性（模拟每只鸭游泳形式是不变化的）
 23     */
 24    public void swim() {
 25        System.out.println("所有鸭子都是一样的游泳");
 26    }
 27
 28    /**
 29     * 不同共性（模拟每只鸭的外表行为是不一样的，但一般不会变化，一次性即可）
 30     */
 31    public abstract void display();
 32
 33    /**
 34     * 委托行为执行者去执行某种具体行为
 35     */
 36    public void doFly() {
 37        flyBehavior.fly();
 38    }
 39}
 40
 41
 42
 43/**
 44 * @author huey
 45 * @Description : 绿头鸭
 46 * @Date Created in 2018/7/3 15:54
 47 */
 48public class MallardDuck extends Duck {
 49
 50    public MallardDuck() {
 51    }
 52
 53    public MallardDuck(FlyBehavior flyBehavior) {
 54        super(flyBehavior);
 55    }
 56
 57    @Override
 58    public void display() {
 59        System.out.println(this.getClass().toString() + "----------》display");
 60    }
 61
 62
 63}
 64
 65
 66
 67/**
 68 * @author huey
 69 * @Description : 橡皮鸭
 70 * @Date Created in 2018/7/3 17:57
 71 */
 72public class XiangPiDuck extends Duck {
 73
 74    public XiangPiDuck(FlyBehavior flyBehavior) {
 75        super(flyBehavior);
 76    }
 77
 78    public XiangPiDuck() {
 79    }
 80
 81    @Override
 82    public void display() {
 83        System.out.println(this.getClass().toString() + "----------》display");
 84    }
 85
 86
 87}
 88
 89
 90/**
 91 * @author huey
 92 * @Description : 飞行行为，（模拟，策略化）
 93 * 你是不是要问100种鸭子，要写100中实现，答案是不是的，可能多种鸭子重复（共用一种行为）
 94 * 。
 95 * @Date Created in 2018/7/3 18:19
 96 */
 97public interface FlyBehavior {
 98
 99    /**
100     * 独立（模拟每只鸭经常变化的行为，一只鸭可能各种姿势飞。。。）
101     */
102    public void fly();
103}
104
105
106/**
107 * @author huey
108 * @Description : 橡皮鸭（模拟某种不会飞的飞行）
109 * @Date Created in 2018/7/3 18:48
110 */
111public class NotFly implements FlyBehavior {
112    /**
113     * 独立（模拟每只鸭经常变化的行为，一只鸭可能各种姿势飞。。。）
114     */
115    @Override
116    public void fly() {
117        System.out.println("橡皮鸭 can't fly");
118    }
119}
120
121
122/**
123 * @author huey
124 * @Description : 绿头鸭（某种飞行方式的具体实现）
125 * @Date Created in 2018/7/3 18:47
126 */
127public class CanFly implements FlyBehavior {
128    /**
129     * 独立（模拟每只鸭经常变化的行为，一只鸭可能各种姿势飞。。。）
130     */
131    @Override
132    public void fly() {
133        System.out.println("绿头鸭 can fly");
134    }
135}

总结：perfect！如果你需要扩展行为，只需要写出FlyBehavior的实现，然后在相应的实例化子类duck传入该行为即可。

读者须知：

1.有的设计模式我们在业务开发并不是很常用，但是框架内部有很多的，有兴趣可以看看一些框架的源码比如经典的spring，流行的springboot，Tomcat等。
2.设计模式理解的是思想，根据具体业务场景，合理使用。
3.即使你现在用不到某些设计模式，但是还是应该理解其原理的。
4.当时理解并不意味着自己已会，可以自己尝试练习，并幻想一种业务场景，画画类图，设计一下。

---

coding 时，做到了如何落实;
writing时，做到了如何表达;
sharing时，做到了如何传授;
thinking时，做到了如何提升;

代码请参考码云:https://gitee.com/tjhuey/CodingGroup
设计模式相关概念请参考:http://naotu.baidu.com/file/5811bf42020e6a2d877b992cfca90d26

进度

√策略模式，已完成

x..，未完成;

x..，未完成;