Android设计模式-策略模式-行为型-(2)

创建型模式 (3)

简单工厂、工厂法、抽象工厂模式、单例模式、建造者模式

行为型模式 (2)

观察者模式、策略模式

结构型模式 (3)

适配器模式、代理模式、装饰模式

• Android设计模式Github项目地址： 点击跳转

---

0. 什么是策略模式？

1、将一组算法，一个个封装到单独的类中并实现统一的接口，这一组算法之间就可以动态的互相切换。
2、同时也避免了在有多种算法相似的情况下，使用 if…else 所带来的复杂和难以维护。
3、例如计算器。这里有2个数，num1和num2。这时我们动态的使用不同的算法让num1和num2进行不同的计算±*/，这时我们就可以用到策略模式来进行写，下面会举例
4、主要目的是把具体的算法抽离出来，把每个算法独立出来。形成一系列有共同作用的算法组，然后这个算法组里面的算法可以根据实际情况进行相互替换。

1. StrategyInterface 抽象策略类，定义算法

2. ConcreteStrategy 具体策略类，实现抽象算法接口

3. Context 上下文类，这里可以理解为是使用的客户端，并切再进一次的封装了策略的具体实现。
   1.Context 类中包含了抽象策略类的接口，并需要通过构造函数或者传参的方式传递具体策略类。
   2.Context 类中对外提供了调用策略的方法。这里当时研究的很难理解为什么还特意写个Context类，又为什么是对策略类的再一次封装？ 通过下面的例子会列举出来原因以及实现，加强理解。

---

1. 优缺点

优点：

1、算法可以自由切换。
2、避免使用多重条件判断。
3、扩展性良好。
4、提高了算法的保密性和安全性

缺点：

1、策略的类会增多
2、所有的策略类必须要露出来，让客户端知道所有的策略，这样才可以自由的切换，调用。

使用场景：

1、如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。
2、一个系统需要动态地在几种算法中选择一种。
3、如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条件选择语句来实现。

注意事项：

如果一个系统的策略多于四个，就需要考虑使用混合模式，解决策略类膨胀的问题。

2. 哪些库或方法使用观察者模式来实现的？

插值器、估值器、缓存策略，增删改查策略，Adapter

---

3. 举例说明-计算其中的 + - * /

1.StrategyInterface类为策略的抽象方法
2.Operation类为 + - * / 具体策略实现类、
3.StrategyContext上下文类
4.StrategyPatternActivity activity类

• 1.StrategyInterface类为策略的抽象方法

/**
 * 创建抽象策略方法
 */
public interface StrategyInterface {
    int doOperation(int num1,int num2); //执行方法
}

2.Operation类为 + - * / 具体策略实现类、

/**
 * 加法
 */
public class OperationAdd implements StrategyInterface {
    @Override
    public int doOperation(int num1,int num2) {
        return num1 + num2;
    }
}

/**
 * 减法
 */
public class OperationSubtract implements StrategyInterface {
    @Override
    public int doOperation(int num1,int num2) {
        return num1 - num2;
    }
}

/**
 * 乘法
 */
public class OperationMultiply implements StrategyInterface {
    @Override
    public int doOperation(int num1,int num2) {
        return num1 * num2;
    }
}

/**
 * 除法
 */
public class OperationDivision implements StrategyInterface {
    @Override
    public int doOperation(int num1,int num2) {
        return num1 / num2;
    }
}

• 3.StrategyContext上下文类

/**
 * 创建Context类-理解为使用策略的客户端
 */
public class StrategyContext {
    public StrategyInterface mStrategyInterface;
    //构造方法，传递接口
    public StrategyContext(StrategyInterface strategyInterface){
        this.mStrategyInterface = strategyInterface;
    }
    public int doCalculate(int num1, int num2){
        int result = mStrategyInterface.doOperation(num1, num2);
        return result;
    }
}

• 4.StrategyPatternActivity activity类

public class StrategyPatternActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_strategy_pattern);
        initial();
    }
    private void initial(){
        int num1 = 10;
        int num2 = 5;
        System.out.println("策略模式:>> num1>> "+num1+" --- num2>> "+num2);

        StrategyContext mStrategyContext = new StrategyContext(new OperationAdd());
        System.out.println("策略模式:>> 加法>> "+mStrategyContext.doCalculate(num1,num2));

                        mStrategyContext = new StrategyContext(new OperationSubtract());
        System.out.println("策略模式:>> 减法>> "+mStrategyContext.doCalculate(num1,num2));

                        mStrategyContext = new StrategyContext(new OperationMultiply());
        System.out.println("策略模式:>> 乘法>> "+mStrategyContext.doCalculate(num1,num2));

                        mStrategyContext = new StrategyContext(new OperationDivision());
        System.out.println("策略模式:>> 除法>> "+mStrategyContext.doCalculate(num1,num2));

    }
}

运行后的结果是：

---

4. Context类的探究

回到开头，为什么说是Context类是对算法的具体实现再一次封装？再一次封装是为了更好的解决后期的需求改变而带来的代码改动。

假如我们对策略的具体实现需求发生了变化，我们要求对num1 和 num2 做+ - * /计算并记录这次的结果。在没有Context类的情况下，我们需要挨个去在算法的具体实现类做更改。（写4遍）

…… +
…… -
…… *
public class OperationDivision implements StrategyInterface {
    @Override
    public int doOperation(int num1,int num2) {
        int result = num1 / num2;
        Log.d("策略模式:>>", "本次执行算法的结果是 "+result);
        return num1 / num2;
    }
}

然而在有Context类的情况下，我们只需要将需求添加到Conext类对外提供的方法中即可。

public class StrategyContext {
    public StrategyInterface mStrategyInterface;
    //构造方法，传递接口
    public StrategyContext(StrategyInterface strategyInterface){
        this.mStrategyInterface = strategyInterface;
    }
    public int doCalculate(int num1, int num2){
        int result = mStrategyInterface.doOperation(num1, num2);
        Log.d("策略模式:>>", "本次执行算法的结果是 "+result);
        return result;
    }
}

那为什么不直接在StrategyPatternActivity 中添加？这样做不但加强了耦合，还破坏了原有的策略模式结构，这次只是添加个log，但是实际上的需求业务可能更复杂。

---

5. Android技术生活交流

微信

---

[1]* 参考文章1
[2]* 参考文章2
[3]* 参考文章3
[4]* 参考文章4
[5]* 参考文章5
[6]* 参考文章6
[7]* 参考文章7
[8]* 参考文章8