《大话设计模式》之策略模式

策略模式

1.定义

定义算法/策略，分别封装起来，让它们之间可以互相替换。把对象本身和运算规则区分开来。

所有这些算法/策略完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法/策略，减小了各种算法类与使用算法类之间的耦合。

只用在分析过程中听到需要在不同时间应用不同的业务规则，就可以考虑使用。

2.实现结构

//定义相同工作的抽象类
public abstract class CashSuper {
    public abstract double acceptCash(double money);
}

public class CashContext {
    //1.声明一个功能类
    private CashSuper cs;
    //2.传入功能类的实现类
    public CashContext(CashSuper cs) {
        this.cs = cs;
    }
    //3.返回功能类的功能，也是实现类的功能实现
    public double GetResult(double money) {
        return  cs.acceptCash(money);
    }
}

//用不同方式完成相同工作
public class CashRebate extends CashSuper {
    private double moneyRebate=1d;  
    public CashRebate(double moneyRebate) {
        this.moneyRebate = moneyRebate;
    }
    @Override
    public double acceptCash(double money) {
        // TODO Auto-generated method stub
        return money*moneyRebate;
    }
}

public class CashNormal extends CashSuper { 
    @Override
    public double acceptCash(double money) {
        return money;
    }
}

//使用
    public void accept(String key){     
        CashContext cc=null;
        switch (key) {
        case "CashNormal":
            cc=new CashContext(new CashNormal());
            break;
        case "CashRebate":
            cc=new CashContext(new CashRebate(0.8));
            break;
        default:
            break;
        }
        double total=cc.GetResult(500);     
    }

以上方法使用策略模式，但是用客服端来判断使用哪个算法。

下面是策略模式与简单工厂结合，使得判断算法放在Context来。

//使用
    public static void main(String[] args) {
        CashContext cc=new CashContext("normal");
        double total=cc.GetResult(300);
        System.out.println(total);
    }

书上还有单独使用工厂模式，客户端使用如下：
CashSuper csuper=CashFatory.createCashAccept("normal");
    ...=csuper.GetResult(...);

区别：
单独使用简单工厂模式，客户端需要认识两个类。

简单工厂模式与策略模式区别：其实这两种模式不是同一种场景同一层面的可替换模式，而是一个场景的不同层面的不同模式。

策略模式：
不同算法封装成不同对象
好处:是算法可独立于使用它的客户而变化.
目标只有一个实现,却有不同方法

工厂模式:
把客户端与不同对象进行解耦
好处:代替了new关键字,
对象之间的依赖降低了
降低了耦合度

因此，这两种模式通常是结合起来一起使用。

以下代码来自《Thinking in java》：

 class Processor {

    public String name(){
        return getClass().getSimpleName();
    }
    Object  process(Object input){
        return input;
    }
}

public class Downcase extends Processor{
    @Override
    String process(Object input){
        return ((String)input).toLowerCase();
    }
}

public class Upcase extends Processor{
    @Override
    String process(Object input){
        return ((String)input).toUpperCase();
    }
}

public class Splitter extends Processor{

    @Override
    String process(Object input){
        return Arrays.toString(((String)input).split(" "));
    }
}

public class Apply {
    public static void process(Processor p,Object s){
        System.out.println("using process"+p.name());
        System.out.println(p.process(s));
    }

    public static String s="sasa sasas";

    public static void main(String[] args) {
        process(new Upcase(), s);
        process(new Downcase(),s);
        process(new Splitter(), s);
        }
}

创建一个能够根据所传递的参数对象的不同而具有不同行为的方法，称为策略模式。