策略模式 — 孔明排兵布阵

前言

本文转载自威威喵,分享了常见的策略模式,非常生动,相信对大家有所帮助。

威威喵的博客地址

https://blog.csdn.net/smile_Running/article/details/81505627

晚上的时候,抽了点时间看了一下设计模式相关书籍,毕竟有些东西还是得重温一下的,脑子不灵光,记住不啊。看着看着就看到了策略设计模式,关于这个策略模式,它书本上是这样定义的:定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。


关于策略模式,这本书上是用了一个理财利率计算的例子,那么理财的软件有非常多,像余额宝这样的,把钱存进去就可以得到一点收入,也是非常不错的。而理财软件并非只有这个,不同的人可能用的软件都不一样,所有这里肯定就有利率计算的区别了。我可能把钱分别投入到不同的理财软件,那么每日收入当然就是不同的了,所有这里就用了不同的收益算法。

那么这里的收益算法必定和软件息息相关,不同的软件收益不同,那我们向不同软件投资就是不同的策略,可能看哪个比较高,就往那个软件里面存一点钱,就用到了策略设计模式。

不过呢,我在看策略设计模式时,忽然想到了三国中的诸葛亮,说到策略,我印象里记忆最深刻的还是诸葛亮了,在三国时期,那策略可真是无以匹敌啊。这样一关联起来,我就马上想写一个诸葛亮排兵布阵的策略模式。

接下来,我要介绍一下代码的意思,故事发生在三国时期,忽然刘备的驻军遭到了敌人的袭击,而五虎上将分别从其他不同的地方赶过来支援,由于派兵需要比对两军之间的战斗力及战耗情况,所以诸葛亮要用最大的利益来换取胜利与战绩。

诸葛亮手下有五虎上将:张飞,关羽,赵云,马超,黄忠。但只能派出一位作战,而且五虎上将的实力各不相同,且拥有的战力和士兵人数也不同。我们来看一下具体情况:

我军大将:

  • 张飞:拥兵 9500 人,战斗力 2.35

  • 关羽:拥兵 9000 人,战斗力 2.45

  • 赵云:拥兵 8500 人,战斗力 2.55

  • 马超:拥兵 10000 人,战斗力 2.30

  • 黄忠:拥兵 11000 人,战斗力 2.20

敌军大将:

  • 曹操:拥兵 18000 人,战斗力 1.20

好了,拟定的战力表已经确定,那么这场战争的胜利和战绩都掌握在诸葛亮手中,诸葛亮利用了一些简单的计算,根据双方的拥兵数量和战力进行了比较,最后得出应该派遣哪一位五虎上将去支援才能获得最好的战绩,还有要考虑战损情况。

接着直接上代码,一个是 诸葛亮 类:

  1package com.xww.dp.strategy;
  2
  3/**
  4 * 诸葛亮,军师策略,发兵操作。
  5 * 
  6 * @author xww
  7 * 
  8 * @博客 :https://blog.csdn.net/smile_running?t=1
  9 *
 10 */
 11public class Zhugeliang {
 12    private int enemy;// 敌军人数
 13    private float enemyfighting;// 战斗力
 14
 15    // 五虎将
 16    public enum Wuhu {
 17        zhangfei, guanyu, zhaoyun, machao, huangzhong
 18    }
 19
 20    public Zhugeliang(int enemy, float fighting) {
 21        this.enemy = enemy;
 22        this.enemyfighting = fighting;
 23    }
 24
 25    // 派遣军队
 26    public String dispatchTroops(Wuhu wuhu) {
 27        switch (wuhu) {
 28        case zhangfei:
 29            return zhangfeiArmy();
 30        case guanyu:
 31            return guanyuArmy();
 32        case zhaoyun:
 33            return zhaoyunArmy();
 34        case machao:
 35            return machaoArmy();
 36        case huangzhong:
 37            return huangzhongArmy();
 38        }
 39        return "";
 40    }
 41
 42    // 张飞的军队
 43    private String zhangfeiArmy() {
 44        int army = 9500;
 45        float fighting = 2.35f;
 46
 47        // 敌人实力
 48        int enemyStrength = (int) (enemy * enemyfighting);
 49        // 我军实力
 50        int zhangfeiStrength = (int) (army * fighting);
 51        // 战斗结果
 52        int soldier = zhangfeiStrength - enemyStrength;
 53
 54        return soldier > 0 ? "战胜!剩余士兵:" + soldier : "战败!";
 55    }
 56
 57    // 关羽的军队
 58    private String guanyuArmy() {
 59        int army = 9000;
 60        float fighting = 2.45f;
 61
 62        // 敌人实力
 63        int enemyStrength = (int) (enemy * enemyfighting);
 64        // 我军实力
 65        int zhangfeiStrength = (int) (army * fighting);
 66        // 战斗结果
 67        int soldier = zhangfeiStrength - enemyStrength;
 68
 69        return soldier > 0 ? "战胜!剩余士兵:" + soldier : "战败!";
 70    }
 71
 72    // 赵云的军队
 73    private String zhaoyunArmy() {
 74        int army = 8500;
 75        float fighting = 2.55f;
 76
 77        // 敌人实力
 78        int enemyStrength = (int) (enemy * enemyfighting);
 79        // 我军实力
 80        int zhangfeiStrength = (int) (army * fighting);
 81        // 战斗结果
 82        int soldier = zhangfeiStrength - enemyStrength;
 83
 84        return soldier > 0 ? "战胜!剩余士兵:" + soldier : "战败!";
 85    }
 86
 87    // 马超的军队
 88    private String machaoArmy() {
 89        int army = 10000;
 90        float fighting = 2.3f;
 91
 92        // 敌人实力
 93        int enemyStrength = (int) (enemy * enemyfighting);
 94        // 我军实力
 95        int zhangfeiStrength = (int) (army * fighting);
 96        // 战斗结果
 97        int soldier = zhangfeiStrength - enemyStrength;
 98
 99        return soldier > 0 ? "战胜!剩余士兵:" + soldier : "战败!";
100    }
101
102    // 黄忠的军队
103    private String huangzhongArmy() {
104        int army = 11000;
105        float fighting = 2.2f;
106
107        // 敌人实力
108        int enemyStrength = (int) (enemy * enemyfighting);
109        // 我军实力
110        int zhangfeiStrength = (int) (army * fighting);
111        // 战斗结果
112        int soldier = zhangfeiStrength - enemyStrength;
113
114        return soldier > 0 ? "战胜!剩余士兵:" + soldier : "战败!";
115    }
116
117}

这个类就是诸葛亮通过对比两军战力的相关算法,对比了五位将军的战力和兵力,通过简单的计算来模拟一下,然后另一个是主类:

 1package com.xww.dp.strategy;
 2
 3import com.xww.dp.strategy.Zhugeliang.Wuhu;
 4
 5public class StrategyPatternClient {
 6
 7    public static void main(String[] args) {
 8
 9        int enemy = getEnemy();
10        float fighting = getFighting();
11
12        Zhugeliang liang = new Zhugeliang(enemy, fighting);
13
14        String result = liang.dispatchTroops(Wuhu.zhangfei);
15
16        //张飞 725
17        //关羽 450
18        //赵云 75
19        //马超 1400
20        //黄忠 2600
21
22        System.out.println(result);
23    }
24
25    public static int getEnemy() {
26        int enemyCount = 18000;
27        System.out.println("获得敌情,敌人数量:" + enemyCount + "人");
28        return enemyCount;
29    }
30
31    public static float getFighting() {
32        float fighting = 1.2f;
33        System.out.println("敌人战力:" + fighting + "倍");
34        return fighting;
35    }
36
37}

根据简单的模拟战斗,可以得出双方交战的战绩情况。我们把五位上将的战绩列出来:

640?wx_fmt=png

640?wx_fmt=png


640?wx_fmt=png
640?wx_fmt=png


640?wx_fmt=png

上面运行结果是每一位的战绩情况,根据没一位将军的拥兵数量和战斗力计算出来的。它们的剩余士兵就是战绩,接下来我们来计算一下他们的战斗损失情况。

战斗损失:

  • 张飞 :拥兵 9500,剩余 725,损失 8775 人

  • 关羽 :拥兵 9000,剩余 450,损失 8550 人

  • 赵云 :拥兵 8500,剩余 75,损失 8425 人

  • 马超 :拥兵 10000,剩余 1400,损失 8600 人

  • 黄忠:拥兵 11000,剩余 2600,损失 8400 人

计算一下战斗损失,还是诸葛亮老谋深算,乍一看 关羽、赵云 比较牛皮,这赵云差点就锤不过了,别看 马超老黄盖 出马,所谓老将出马,一个顶俩。

好了,这个例子就是这样的,也是我自己瞎想着玩的,感觉非常有意思,就用代码实现了一下。至此,我们还没有用上策略模式,虽然诸葛亮料事如神,

策略模式的运用

接下来,才是我们的策略模式具体使用情况,关于策略模式的定义,它是说把这一系列算法一个一个的封装起来,并且使其能够相互替换。这样的话,我们上面代码中的算法部分,就只有五虎上将和敌军的战力比较情况了,比如这一部分:

 1    // 赵云的军队
 2    private String zhaoyunArmy() {
 3        int army = 8500;
 4        float fighting = 2.55f;
 5
 6        // 敌人实力
 7        int enemyStrength = (int) (enemy * enemyfighting);
 8        // 我军实力
 9        int zhangfeiStrength = (int) (army * fighting);
10        // 战斗结果
11        int soldier = zhangfeiStrength - enemyStrength;
12
13        return soldier > 0 ? "战胜!剩余士兵:" + soldier : "战败!";
14    }

根据策略模式的使用规则,要把算法封装为一个类,也就是把上部分代码封装到类里面去。有了这样的思想,我们事情就好办了,为五虎上将建立五个类,把算法搬到里面去,这是第一步要做的。

策略模式还指出需要根据算法替换不同的类,也就是诸葛亮可以派遣五虎上将中的任何一位都可以,所以这里需要一个接口,根据多态性,我们可以传入它的不同实现类。下面开始着手改为策略模式吧!

首先,新建一个接口,传入敌军的人数和战力值,返回的是战斗结果,如下:

 1package com.xww.dp.strategy;
 2
 3/**
 4 * 诸葛亮策略接口
 5 * 
 6 * @author xww
 7 * @博客 https://blog.csdn.net/smile_running?t=1
 8 */
 9public interface ZhugeliangStrategy {
10
11    // 派遣五虎上将
12    String wuhu(int enemy, float enemyFlighting);
13}

接下来是对每一个五虎上将的算法封装,代码如下:

 1package com.xww.dp.strategy;
 2
 3/**
 4 * 五虎上将 - 张飞
 5 * 
 6 * @author xww
 7 *
 8 */
 9public class ZhangFei implements ZhugeliangStrategy {
10
11    public ZhangFei() {
12
13    }
14
15    @Override
16    public String wuhu(int enemy, float enemyFlighting) {
17        int army = 9500;
18        float fighting = 2.35f;
19
20        // 敌人实力
21        int enemyStrength = (int) (enemy * enemyFlighting);
22        // 我军实力
23        int zhangfeiStrength = (int) (army * fighting);
24        // 战斗结果
25        int soldier = zhangfeiStrength - enemyStrength;
26
27        return soldier > 0 ? "战胜!剩余士兵:" + soldier : "战败!";
28    }
29}

要实现刚刚创建的策略接口,把算法部分考过来就行了,剩余四个都是这样的操作,看看就懂了。关羽类的代码:

 1package com.xww.dp.strategy;
 2
 3public class GuanYu implements ZhugeliangStrategy {
 4
 5    public GuanYu() {
 6
 7    }
 8
 9    @Override
10    public String wuhu(int enemy, float enemyFlighting) {
11        int army = 8500;
12        float fighting = 2.55f;
13
14        // 敌人实力
15        int enemyStrength = (int) (enemy * enemyFlighting);
16        // 我军实力
17        int zhangfeiStrength = (int) (army * fighting);
18        // 战斗结果
19        int soldier = zhangfeiStrength - enemyStrength;
20
21        return soldier > 0 ? "战胜!剩余士兵:" + soldier : "战败!";
22    }
23
24}

剩下的赵云、马超、黄忠三个类就不贴代码了,几乎一摸一样。接着,诸葛亮类也需要做出相应的修改,我们之前的派遣军队是一个 enum

 1package com.xww.dp.strategy;
 2
 3/**
 4 * 诸葛亮,军师策略,发兵操作。
 5 * 
 6 * @author xww
 7 * 
 8 * @博客 :https://blog.csdn.net/smile_running?t=1
 9 *
10 */
11public class Zhugeliang {
12    private int enemy;// 敌军人数
13    private float enemyfighting;// 战斗力
14
15    public Zhugeliang(int enemy, float fighting) {
16        this.enemy = enemy;
17        this.enemyfighting = fighting;
18    }
19
20    // 派遣军队
21    public String dispatchTroops(ZhugeliangStrategy strategy) {
22        return strategy.wuhu(enemy, enemyfighting);
23    }
24
25}

对比一下,算法部分全部被移到了每一个类中,而且诸葛亮类也与几个五虎上将解耦了,他们通过一个接口联系。最后,我们的客户端就可以这样调用了:

 1package com.xww.dp.strategy;
 2
 3public class StrategyPatternClient {
 4
 5    public static void main(String[] args) {
 6
 7        int enemy = getEnemy();
 8        float fighting = getFighting();
 9
10        Zhugeliang liang = new Zhugeliang(enemy, fighting);
11
12        // 这里直接 new 策略的实现类
13        String result = liang.dispatchTroops(new HuangZhong());
14
15        System.out.println(result);
16    }
17
18    public static int getEnemy() {
19        int enemyCount = 18000;
20        System.out.println("获得敌情,敌人数量:" + enemyCount + "人");
21        return enemyCount;
22    }
23
24    public static float getFighting() {
25        float fighting = 1.2f;
26        System.out.println("敌人战力:" + fighting + "倍");
27        return fighting;
28    }
29
30}

好了,这就是策略模式的基本代码了,把每个算法封装为类,提供一个算法的接口,通过实现该接口实现不同的算法,然后调用时,只要有 new

晚上的时候,抽了点时间看了一下设计模式相关书籍,毕竟有些东西还是得重温一下的,脑子不灵光,记住不啊。看着看着就看到了策略设计模式,关于这个策略模式,它书本上是这样定义的:定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。


关于策略模式,这本书上是用了一个理财利率计算的例子,那么理财的软件有非常多,像余额宝这样的,把钱存进去就可以得到一点收入,也是非常不错的。而理财软件并非只有这个,不同的人可能用的软件都不一样,所有这里肯定就有利率计算的区别了。我可能把钱分别投入到不同的理财软件,那么每日收入当然就是不同的了,所有这里就用了不同的收益算法。

那么这里的收益算法必定和软件息息相关,不同的软件收益不同,那我们向不同软件投资就是不同的策略,可能看哪个比较高,就往那个软件里面存一点钱,就用到了策略设计模式。

不过呢,我在看策略设计模式时,忽然想到了三国中的诸葛亮,说到策略,我印象里记忆最深刻的还是诸葛亮了,在三国时期,那策略可真是无以匹敌啊。这样一关联起来,我就马上想写一个诸葛亮排兵布阵的策略模式。

接下来,我要介绍一下代码的意思,故事发生在三国时期,忽然刘备的驻军遭到了敌人的袭击,而五虎上将分别从其他不同的地方赶过来支援,由于派兵需要比对两军之间的战斗力及战耗情况,所以诸葛亮要用最大的利益来换取胜利与战绩。

诸葛亮手下有五虎上将:张飞,关羽,赵云,马超,黄忠。但只能派出一位作战,而且五虎上将的实力各不相同,且拥有的战力和士兵人数也不同。我们来看一下具体情况:

我军大将:

  • 张飞:拥兵 9500 人,战斗力 2.35

  • 关羽:拥兵 9000 人,战斗力 2.45

  • 赵云:拥兵 8500 人,战斗力 2.55

  • 马超:拥兵 10000 人,战斗力 2.30

  • 黄忠:拥兵 11000 人,战斗力 2.20

敌军大将:

  • 曹操:拥兵 18000 人,战斗力 1.20

好了,拟定的战力表已经确定,那么这场战争的胜利和战绩都掌握在诸葛亮手中,诸葛亮利用了一些简单的计算,根据双方的拥兵数量和战力进行了比较,最后得出应该派遣哪一位五虎上将去支援才能获得最好的战绩,还有要考虑战损情况。

接着直接上代码,一个是 诸葛亮 类:

  1package com.xww.dp.strategy;
  2
  3/**
  4 * 诸葛亮,军师策略,发兵操作。
  5 * 
  6 * @author xww
  7 * 
  8 * @博客 :https://blog.csdn.net/smile_running?t=1
  9 *
 10 */
 11public class Zhugeliang {
 12    private int enemy;// 敌军人数
 13    private float enemyfighting;// 战斗力
 14
 15    // 五虎将
 16    public enum Wuhu {
 17        zhangfei, guanyu, zhaoyun, machao, huangzhong
 18    }
 19
 20    public Zhugeliang(int enemy, float fighting) {
 21        this.enemy = enemy;
 22        this.enemyfighting = fighting;
 23    }
 24
 25    // 派遣军队
 26    public String dispatchTroops(Wuhu wuhu) {
 27        switch (wuhu) {
 28        case zhangfei:
 29            return zhangfeiArmy();
 30        case guanyu:
 31            return guanyuArmy();
 32        case zhaoyun:
 33            return zhaoyunArmy();
 34        case machao:
 35            return machaoArmy();
 36        case huangzhong:
 37            return huangzhongArmy();
 38        }
 39        return "";
 40    }
 41
 42    // 张飞的军队
 43    private String zhangfeiArmy() {
 44        int army = 9500;
 45        float fighting = 2.35f;
 46
 47        // 敌人实力
 48        int enemyStrength = (int) (enemy * enemyfighting);
 49        // 我军实力
 50        int zhangfeiStrength = (int) (army * fighting);
 51        // 战斗结果
 52        int soldier = zhangfeiStrength - enemyStrength;
 53
 54        return soldier > 0 ? "战胜!剩余士兵:" + soldier : "战败!";
 55    }
 56
 57    // 关羽的军队
 58    private String guanyuArmy() {
 59        int army = 9000;
 60        float fighting = 2.45f;
 61
 62        // 敌人实力
 63        int enemyStrength = (int) (enemy * enemyfighting);
 64        // 我军实力
 65        int zhangfeiStrength = (int) (army * fighting);
 66        // 战斗结果
 67        int soldier = zhangfeiStrength - enemyStrength;
 68
 69        return soldier > 0 ? "战胜!剩余士兵:" + soldier : "战败!";
 70    }
 71
 72    // 赵云的军队
 73    private String zhaoyunArmy() {
 74        int army = 8500;
 75        float fighting = 2.55f;
 76
 77        // 敌人实力
 78        int enemyStrength = (int) (enemy * enemyfighting);
 79        // 我军实力
 80        int zhangfeiStrength = (int) (army * fighting);
 81        // 战斗结果
 82        int soldier = zhangfeiStrength - enemyStrength;
 83
 84        return soldier > 0 ? "战胜!剩余士兵:" + soldier : "战败!";
 85    }
 86
 87    // 马超的军队
 88    private String machaoArmy() {
 89        int army = 10000;
 90        float fighting = 2.3f;
 91
 92        // 敌人实力
 93        int enemyStrength = (int) (enemy * enemyfighting);
 94        // 我军实力
 95        int zhangfeiStrength = (int) (army * fighting);
 96        // 战斗结果
 97        int soldier = zhangfeiStrength - enemyStrength;
 98
 99        return soldier > 0 ? "战胜!剩余士兵:" + soldier : "战败!";
100    }
101
102    // 黄忠的军队
103    private String huangzhongArmy() {
104        int army = 11000;
105        float fighting = 2.2f;
106
107        // 敌人实力
108        int enemyStrength = (int) (enemy * enemyfighting);
109        // 我军实力
110        int zhangfeiStrength = (int) (army * fighting);
111        // 战斗结果
112        int soldier = zhangfeiStrength - enemyStrength;
113
114        return soldier > 0 ? "战胜!剩余士兵:" + soldier : "战败!";
115    }
116
117}

这个类就是诸葛亮通过对比两军战力的相关算法,对比了五位将军的战力和兵力,通过简单的计算来模拟一下,然后另一个是主类:

 1package com.xww.dp.strategy;
 2
 3import com.xww.dp.strategy.Zhugeliang.Wuhu;
 4
 5public class StrategyPatternClient {
 6
 7    public static void main(String[] args) {
 8
 9        int enemy = getEnemy();
10        float fighting = getFighting();
11
12        Zhugeliang liang = new Zhugeliang(enemy, fighting);
13
14        String result = liang.dispatchTroops(Wuhu.zhangfei);
15
16        //张飞 725
17        //关羽 450
18        //赵云 75
19        //马超 1400
20        //黄忠 2600
21
22        System.out.println(result);
23    }
24
25    public static int getEnemy() {
26        int enemyCount = 18000;
27        System.out.println("获得敌情,敌人数量:" + enemyCount + "人");
28        return enemyCount;
29    }
30
31    public static float getFighting() {
32        float fighting = 1.2f;
33        System.out.println("敌人战力:" + fighting + "倍");
34        return fighting;
35    }
36
37}

根据简单的模拟战斗,可以得出双方交战的战绩情况。我们把五位上将的战绩列出来:

640?wx_fmt=png
640?wx_fmt=png
640?wx_fmt=png
640?wx_fmt=png
640?wx_fmt=png

上面运行结果是每一位的战绩情况,根据没一位将军的拥兵数量和战斗力计算出来的。它们的剩余士兵就是战绩,接下来我们来计算一下他们的战斗损失情况。

战斗损失:

  • 张飞 :拥兵 9500,剩余 725,损失 8775 人

  • 关羽 :拥兵 9000,剩余 450,损失 8550 人

  • 赵云 :拥兵 8500,剩余 75,损失 8425 人

  • 马超 :拥兵 10000,剩余 1400,损失 8600 人

  • 黄忠:拥兵 11000,剩余 2600,损失 8400 人

计算一下战斗损失,还是诸葛亮老谋深算,乍一看 关羽、赵云 比较牛皮,这赵云差点就锤不过了,别看 马超老黄盖 出马,所谓老将出马,一个顶俩。

好了,这个例子就是这样的,也是我自己瞎想着玩的,感觉非常有意思,就用代码实现了一下。至此,我们还没有用上策略模式,虽然诸葛亮料事如神,

策略模式的运用

接下来,才是我们的策略模式具体使用情况,关于策略模式的定义,它是说把这一系列算法一个一个的封装起来,并且使其能够相互替换。这样的话,我们上面代码中的算法部分,就只有五虎上将和敌军的战力比较情况了,比如这一部分:

 1    // 赵云的军队
 2    private String zhaoyunArmy() {
 3        int army = 8500;
 4        float fighting = 2.55f;
 5
 6        // 敌人实力
 7        int enemyStrength = (int) (enemy * enemyfighting);
 8        // 我军实力
 9        int zhangfeiStrength = (int) (army * fighting);
10        // 战斗结果
11        int soldier = zhangfeiStrength - enemyStrength;
12
13        return soldier > 0 ? "战胜!剩余士兵:" + soldier : "战败!";
14    }

根据策略模式的使用规则,要把算法封装为一个类,也就是把上部分代码封装到类里面去。有了这样的思想,我们事情就好办了,为五虎上将建立五个类,把算法搬到里面去,这是第一步要做的。

策略模式还指出需要根据算法替换不同的类,也就是诸葛亮可以派遣五虎上将中的任何一位都可以,所以这里需要一个接口,根据多态性,我们可以传入它的不同实现类。下面开始着手改为策略模式吧!

首先,新建一个接口,传入敌军的人数和战力值,返回的是战斗结果,如下:

 1package com.xww.dp.strategy;
 2
 3/**
 4 * 诸葛亮策略接口
 5 * 
 6 * @author xww
 7 * @博客 https://blog.csdn.net/smile_running?t=1
 8 */
 9public interface ZhugeliangStrategy {
10
11    // 派遣五虎上将
12    String wuhu(int enemy, float enemyFlighting);
13}

接下来是对每一个五虎上将的算法封装,代码如下:

 1package com.xww.dp.strategy;
 2
 3/**
 4 * 五虎上将 - 张飞
 5 * 
 6 * @author xww
 7 *
 8 */
 9public class ZhangFei implements ZhugeliangStrategy {
10
11    public ZhangFei() {
12
13    }
14
15    @Override
16    public String wuhu(int enemy, float enemyFlighting) {
17        int army = 9500;
18        float fighting = 2.35f;
19
20        // 敌人实力
21        int enemyStrength = (int) (enemy * enemyFlighting);
22        // 我军实力
23        int zhangfeiStrength = (int) (army * fighting);
24        // 战斗结果
25        int soldier = zhangfeiStrength - enemyStrength;
26
27        return soldier > 0 ? "战胜!剩余士兵:" + soldier : "战败!";
28    }
29}

要实现刚刚创建的策略接口,把算法部分考过来就行了,剩余四个都是这样的操作,看看就懂了。关羽类的代码:

 1package com.xww.dp.strategy;
 2
 3public class GuanYu implements ZhugeliangStrategy {
 4
 5    public GuanYu() {
 6
 7    }
 8
 9    @Override
10    public String wuhu(int enemy, float enemyFlighting) {
11        int army = 8500;
12        float fighting = 2.55f;
13
14        // 敌人实力
15        int enemyStrength = (int) (enemy * enemyFlighting);
16        // 我军实力
17        int zhangfeiStrength = (int) (army * fighting);
18        // 战斗结果
19        int soldier = zhangfeiStrength - enemyStrength;
20
21        return soldier > 0 ? "战胜!剩余士兵:" + soldier : "战败!";
22    }
23
24}

剩下的赵云、马超、黄忠三个类就不贴代码了,几乎一摸一样。接着,诸葛亮类也需要做出相应的修改,我们之前的派遣军队是一个 enum

 1package com.xww.dp.strategy;
 2
 3/**
 4 * 诸葛亮,军师策略,发兵操作。
 5 * 
 6 * @author xww
 7 * 
 8 * @博客 :https://blog.csdn.net/smile_running?t=1
 9 *
10 */
11public class Zhugeliang {
12    private int enemy;// 敌军人数
13    private float enemyfighting;// 战斗力
14
15    public Zhugeliang(int enemy, float fighting) {
16        this.enemy = enemy;
17        this.enemyfighting = fighting;
18    }
19
20    // 派遣军队
21    public String dispatchTroops(ZhugeliangStrategy strategy) {
22        return strategy.wuhu(enemy, enemyfighting);
23    }
24
25}

对比一下,算法部分全部被移到了每一个类中,而且诸葛亮类也与几个五虎上将解耦了,他们通过一个接口联系。最后,我们的客户端就可以这样调用了:

 1package com.xww.dp.strategy;
 2
 3public class StrategyPatternClient {
 4
 5    public static void main(String[] args) {
 6
 7        int enemy = getEnemy();
 8        float fighting = getFighting();
 9
10        Zhugeliang liang = new Zhugeliang(enemy, fighting);
11
12        // 这里直接 new 策略的实现类
13        String result = liang.dispatchTroops(new HuangZhong());
14
15        System.out.println(result);
16    }
17
18    public static int getEnemy() {
19        int enemyCount = 18000;
20        System.out.println("获得敌情,敌人数量:" + enemyCount + "人");
21        return enemyCount;
22    }
23
24    public static float getFighting() {
25        float fighting = 1.2f;
26        System.out.println("敌人战力:" + fighting + "倍");
27        return fighting;
28    }
29
30}

好了,这就是策略模式的基本代码了,把每个算法封装为类,提供一个算法的接口,通过实现该接口实现不同的算法,然后调用时,只要有 new

推荐阅读

Android 面试必备 - 知识图谱

致刚入职场的你 - 程序员的成长笔记

干起来,你就超过了 50% 的人

一个程序员的五年总结,给你不一样的角度

Fragment全解析系列(一):那些年踩过的坑

Fragment全解析系列(二):正确的使用姿势

带你全面了解 Android 内存优化

Android自定义控件进阶篇,自定义LayoutManager

640?wx_fmt=jpeg
stormjun94

扫一扫,欢迎关注我的公众号 stormjun94。如果你有好的文章,也欢迎你的投稿。

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 数字20 设计师:CSDN官方博客 返回首页