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

策略模式

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);
}
}

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