设计模式之---策略模式

1.定义

策略模式定义了一系列算法,并将每一个算法封装起来,而且使他们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。

这种定义的语句总是有一种通病,喜欢把一个简单事物复杂化,这里举个例子来说明一下策略模式到底是用来干啥的。

比如我用代码来解一道数学题,然后由于本人是一个天才,牛逼到不行的那种,我可以用N种解法来求解。每种解法都是一种解决方案,但每次使用时,需要根据外在的约束条件来决定到底使用哪种算法来求解,原来的方法大概是来一个switch,搞很多case,来决定到底用哪个方案。这种方式一旦要修改就比较麻烦了,现在可以用策略模式来处理这种问题了。


看图说话

附上UML图一张:
图片来源与网络

策略模式

分析一下这个图,在contect中有三种算法A,B,C可以解决,于是将这三种算法独立出去成为单独的类,他们有一个共同的父类,而Context类不需要与具体的算法类接触。


还是看看代码具体的实现

光看这个图还是比较模糊的。

先看一下算法的父类:

//算法的抽象父类
public abstract class StrategyAbs {

    //每一个算法中都应该有的方法
    abstract boolean DoWork();
}

所有的算法的具体实现不同,但是他们最终实现的功能或效果应该是相同的,因此讲道理是可以提取出一个或多个方法的。

然后是算法的具体实现:

//算法
public class AStrategy extends StrategyAbs {
    private static final String TAG = "Strategy";

    @Override
    void DoWork() {
        Log.d(TAG, "DoWork: i am A,i am working now");
    }
}

这里假设有A,B,C三种算法,都是一样的,这里只列出A的代码。

StrategyUtil:

class StrategyUtil {
    private StrategyAbs strategyAbs;

    //调用者在这里传进来的就是调用者想要使用的A,还是B还是C
    //传进来的都是StrategyAbs的子类,所以用StrategyAbs可以统一接收
    public void setStrategyType(StrategyAbs strategyType) {
        strategyAbs = strategyType;
    }

    //调用父类的方法,而父类的方法是抽象的,所以会自动执行相应子类的方法
    public void work() {
        strategyAbs.DoWork();
    }
}

调用者只会和这个类接触,调用者因此不用关心具体算法类是怎么实现的。

最后看到底怎么去调用:

xml布局:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="st.zlei.com.strategypattern.MainActivity"
    android:orientation="vertical">

    <Button
        android:id="@+id/a_button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="do work By A!"
         />

    <Button
        android:id="@+id/b_button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="do work By B!"
        />
    <Button
        android:id="@+id/c_button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="do work By C!"
        />

    <Button
        android:id="@+id/overAll_button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="do work By C!"
        />
</LinearLayout>

xml布局很简单,就长这样:

xml布局

实现的功能是点击不同的Button,就采用不同的策略。

调用者:

       a_button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //获取对象
                StrategyUtil strategyUtil = new StrategyUtil();
                //通过setStrategyType注入想要采用策略类型
                strategyUtil.setStrategyType(new AStrategy());
                //调用策略的方法
                strategyUtil.work();
            }
        });

        b_button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                StrategyUtil strategyUtil = new StrategyUtil();
                strategyUtil.setStrategyType(new BStrategy());
                strategyUtil.work();
            }
        });

        c_button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                StrategyUtil strategyUtil = new StrategyUtil();
                strategyUtil.setStrategyType(new CStrategy());
                strategyUtil.work();
            }
        });

最后看一下打印结果:

打印结果

可以看到点击A按钮,策略A就开始working,点击B按钮,策略B开始working,点击C按钮,策略C开始working。

还有一点就是这种写法还可以自定义一种策略:

        a_button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //获取对象
                StrategyUtil strategyUtil = new StrategyUtil();
                //通过setStrategyType注入想要采用策略类型
                //当在这里不传子类策略的对象,而是直接new 一个父类的抽象类,就必须要重写DoWork方法,已达到自定义的功能
                strategyUtil.setStrategyType(new StrategyAbs() {
                    @Override
                    boolean DoWork() {
                        return false;
                    }
                });
                //调用策略的方法
                strategyUtil.work();
            }
        });

番外:

现在假设有一种需求,我希望优先使用A策略,其次使用B策略,当A,B策略都无法工作时,才采用C策略。

这时候xml代码多加一个button了,像这样:

    <Button
        android:id="@+id/overAll_button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="do work First By A then B then C"
        />

修改一下A,B,C策略的方法:

public class AStrategy extends StrategyAbs {
    private static final String TAG = "Strategy";

    //当返回true的时候,表示A策略可以正常工作,false表示A策略无法工作
    @Override
    boolean DoWork() {
        Random random = new Random();
        boolean b = random.nextBoolean();
        if (b){
            Log.d(TAG, "DoWork: i am A,i am working now");
        }else {
            Log.d(TAG, "DoWork: i am A,i am busying");
        }
        return b;
    }
}

public class BStrategy extends StrategyAbs {
    private static final String TAG = "Strategy";
    //当返回true的时候,表示B策略可以正常工作,false表示B策略无法工作
    @Override
    boolean DoWork() {
        Random random = new Random();
        boolean b = random.nextBoolean();
        if (b){
            Log.d(TAG, "DoWork: i am B,i am working now");
        }else {
            Log.d(TAG, "DoWork: i am B,i am busying");
        }
        return b;
    }
}

public class CStrategy extends StrategyAbs {
    private static final String TAG = "Strategy";

    @Override
    boolean DoWork() {
        //c策略作为A,B,的备用策略,它必须要保证自己是可用的。
        Log.d(TAG, "DoWork: i am C,i am working now");

        return true;
    }
}

添加一个策略
使用这个策略就可以按照需求顺序使用A,B,C策略

class OverALlStrategy extends StrategyAbs {
    AStrategy aStrategy = new AStrategy();
    BStrategy bStrategy = new BStrategy();
    CStrategy cStrategy = new CStrategy();
    @Override
    boolean DoWork() {
        if (!aStrategy.DoWork()) {
            if (!bStrategy.DoWork()) {
                cStrategy.DoWork();
            }
        }
        return false;
    }
}

调用者:

        overAll_button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                StrategyUtil strategyUtil = new StrategyUtil();
                strategyUtil.setStrategyType(new OverALlStrategy());
                strategyUtil.work();
            }
        });

再看一下打印结果:


A可以工作
A不可以工作,B可以工作
AB都不可以工作,C可以工作

满足了优先使用A策略,再使用B策略,最后使用C策略的要求。


总结

到这里策略模式就讲完了,这种模式的可扩展性,可维护性更好,核心内容就在于setStrategyType这个方法,传入的是具体的策略子类,但是用抽象父类的引用去接收,接收的始终不变,可是传入的可以改变成不同的策略。因此要求所有子类的功能实现的方法是统一的,以便被抽象到父类中去。举个例子比如A,B,C策略的功能实现的方法都叫叫DoWork,父类才可以有抽象的方法DoWork,然后根据setStrategyType传入的具体策略的类型,会自动调用相应子类的DoWork方法,如果A策略的功能方法叫methodA,B策略的功能方法叫methodB,C策略的功能方法叫methodC。那么父类是无法调用的,因为父类是无法知道该调用哪个的。

这文使用的代码可以在本人github上找到-->传送门

推荐阅读更多精彩内容

  • Spring Cloud为开发人员提供了快速构建分布式系统中一些常见模式的工具(例如配置管理,服务发现,断路器,智...
    卡卡罗2017阅读 120,978评论 16 134
  • 工厂模式类似于现实生活中的工厂可以产生大量相似的商品,去做同样的事情,实现同样的效果;这时候需要使用工厂模式。简单...
    舟渔行舟阅读 6,662评论 2 17
  • 中国首届新微商暨网红颁奖盛典-傲华荟,在最具微商代表的城市——广州,完美的落下帷幕,本次大会超人气圆满成功!傲华荟...
    中道文化阅读 218评论 0 0
  • 给定一个整数数组,找到一个具有最大和的子数组,返回其最大和。样例给出数组[−2,2,−3,4,−1,2,1,−5,...
    yzawyx0220阅读 250评论 0 1
  • 有人问,大学室友对自己的成长影响大吗?我说,影响简直不要太大。 大学四年,大部分人接触最多的还是室友。关上门男生一...
    太阳的森林阅读 388评论 0 3