6.JAVA策略方法模式总结

0.抛出问题

在软件构建过程中,某些对象使用的算法可能多种多样,经常改变。如果将这些算法都编码在一个对象中,会使得对象变得异常复杂,而且支持不使用的算法也是一个性能负担。如何在运行时候根据需要更改对象的算法,将算法和对象本身解耦?

1.具体场景

假设我们现在有一家跨国公司需要计算每个国家的关税(目前业务涉及中国、美国、法国),设计软件

第一版代码

//枚举类型定义三个参数
public enum TaxBase {
    CN_TAX,
    US_TAX,
    FR_TAX
}
public class SalesOrder {
    TaxBase taxBase;
    public void CalculateTax(){
        switch (taxBase){
           case CN_TAX:
                System.out.println("假设这是一堆很复杂的算法");
                System.out.println("中国关税");
                break;
            case FR_TAX:
                System.out.println("假设这是一堆很复杂的算法");
                System.out.println("法国关税");
                break;
            case US_TAX:
                System.out.println("假设这是一堆很复杂的算法");
                System.out.println("美国关税");
                break;
        }
    }

    public void setTaxBase(TaxBase taxBase) {
        this.taxBase = taxBase;
    }
}
public class Main {
    public static void main(String[] args)
    {
        SalesOrder salesOrder = new SalesOrder();
        salesOrder.setTaxBase(TaxBase.CN_TAX);
        salesOrder.CalculateTax();
    }
}
//运行结果
假设这是一堆很复杂的算法
中国关税
Process finished with exit code 0

可以说上面的代码是非常非常的简单了,经过前几篇的文章的总结,这里面的设计缺陷已经被重复无数次了,代码复用性不够,要是业务有扩展添加英国关税后,需要修改SalesOrder类源代码,而且将所有的算法都写在同一个类里面,如果哪天公司业务遍布全球232个国家和地区,那这个类可太臃肿了。必须改改改!!!

2.改进


类图分析,定义一个Strategy接口(所有关税算法的抽象接口),然后在Context类中根据需要来创建具体的算法对象

//公共接口
public interface TaxStrategy {
    double calculate();
}
public class FRTaxStrategy implements TaxStrategy {
    @Override
    public double calculate() {
        System.out.println("假设这是一堆很复杂的算法");
        System.out.println("法国关税");
        return 0;
    }
}
public class CNTaxStrategy implements TaxStrategy {
    @Override
    public double calculate() {
        System.out.println("假设这是一堆很复杂的算法");
        System.out.println("中国关税");
        return 0;
    }
}
public class USTaxStrategy implements TaxStrategy {
    @Override
    public double calculate() {
        System.out.println("假设这是一堆很复杂的算法");
        System.out.println("美国关税");
        return 0;
    }
}
//上下文
public class Context {
    private TaxStrategy taxStrategy;
    //根据传过来的字节码去反射创建相应对象
    public Context(Class taxStrategyClass) {
        try {
            taxStrategy=taxStrategyClass.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    public void execute(){
        taxStrategy.calculate();
    }
}
public class Main {
    public static void main(String[] args)
    {
        Context context = new Context(CNTaxStrategy.class);
        context.execute();
    }
}
//运行结果
假设这是一堆很复杂的算法
中国关税

Process finished with exit code 0

这样写的话我们在需要添加新关税算法只需要用一个类去实现TaxStrategy接口就好了,问题被解决。

2.总结

上面的代码其实很像简单工厂模式,笔者在刚接触的时候觉得基本一模一样,现在细说一下他们的区别。

简单工厂模式的实质是由一个工厂类根据传入的参数,动态决定应该创建并且返回哪一 个产品类(这些产品类继承自一个父类或接口)的实例。
那么也就是说:
1、有已知的产品类
2、你无法准确的知道编译哪个产品类
3、需要在运行时决定创建哪个产品类
4、产品类不多
很明显看出,在创建对象上的灵活性高

策略模式它定义了一系列的算法,并将每一个算法封装起来,而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。在一段代码里,使用了逻辑控制(if-else,swich-case)来决定算法,算法有相似的方法和函数,就可以选择策略模式。
那么也就是说:
1、某方法里有多个条件语句,条件语句代码块里有许多行为过程。
2、其算法能封装到策略类
3、算法随意切换
4、算法与客户端隔离
这样一来,通过选择对应的策略类,作为参数传到Content类里,在运行时配置对应的算法。

可以看出,两者解决的问题不同。简单工厂模式是解决产品类的统一分发、策略模式是为了解决策略的切换和扩展。

你可能感兴趣的:(6.JAVA策略方法模式总结)