第二章 策略模式

面向对象的编程，并不是类越多越好，类的划分是为了封装，但分类的基础是抽象，具有相同属性和功能的对象的抽象集合才是类。
收费对象生成工厂
策略模式strategy：它定义了算法家族，分别封装起来，让他们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的用户。
商场收银时如何促销，用打折还是返利，其实都是一些算法，用工厂来生成算法对象，这没有错，但是算法本身只是一种策略，最重要的是这些算法是随时都可能互相替换的，这就是变化点，二封装变化点是我们面向对象的一种很重要的思维方式。
策略模式解析
策略模式是一种定义一系列算法的方法，从概念上来看，所有这些算法完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合。
策略模式的Strategy类层次为Context定义了一系列的可供重用的算法或行为。继承有助于析取出这些算法中的公共功能。
另外一个策略模式的优点是简化了单元测试，以为每个算法都有自己的类，可以通过自己的接口单独测试。

策略模式就是用来封装算法的，但在实践中，我们发现可以用它来封装几乎任何类型的规则，只要在分析过程中听到需要在不同时间应用不同的业务规则，就可以考虑使用策略模式处理这种变化的可能性。

public class Context {
private CashSuper cash;
// public Context(CashSuper cash) {
// this.cash = cash;
// }
//简单工厂模式改造后的构造函数
public Context(int type){
switch(type){
case 1:
cash = new CashNormal();
break;
case 2:
cash = new CashRebate(0.5);
break;
case 3:
cash = new CashReturn(200,50);
break;
}
}

// 上下文接口
public double ContextInterface(double money) {
return cash.acceptCash(money);
}
}

-------------------------------------------------------------------------------------------

策略模式是比较常用的一种模式.封装不算法。每一个算法封装在不同类中。然后根据客户端的需求。选择相应的算法。

策略模式主要角色：

环境角色：一般会持有策略类的父类引用。

抽象策略角色：提供策略类的共有行为和接口。

具体策略角色：每个策略包装一种算法和行为。

现在以人不同方式回家为例。。把每种回家方式封装成一个不同的算法，分别封装在不同的类中

//抽象回家方式接口。封装一个父类接口

public interface GoHomeStrategy{

//不同回家方式，不同算法行为

public void howGoHome()；

}

//走路回家的策略方式。

public class WalkGoHomeStrategy implements GoHomeStrategy{

//回家的方式 走路

public void howGoHome(){

System.out.println("今天我要走路回家...想运动了！");

}

}

//骑自行车回家的方式 不同算法。

public class BikeGoHomeStrategy implements GoHomeStrategy{

//骑车回家的方法。不同算法的方法

public void howGoHome(){

System.out.println("腿有点酸。我要骑车回家！");

}

}

//环境角色。可以选择不同的算法。根据客户端需求 来选择相应的算法。

public class GoHomeContext{

//策略的引用对象变量

private GoHomeStrategy goHome;

private static GoHomeContext instance = new GoHomeContext();

private GoHomeContext(){}

public staticGoHomeContext getInstance(){

return instance;

}

public void operation(int i ){

//根据参数判断来选择相应的策略

if(i==0){

goHome = new WalkGoHomeStrategy ();

}else {

goHome = new BikeGoHomeStrategy ();

}

goHome.howGoHome();

}

}

//客户端调用

public class Client{

public static void main(String args[]){

GoHomeContext context = GoHomeContext.getInstance();

//选择走路回家发方式

context.operation(0);

//选择骑车走路的方式

context.operation(1);

}

}

//打印结果

今天我要走路回家...想运动了！"；

腿有点酸。我要骑车回家！"；

客户端根据不同的参数，选择不同的算法回家

策略模式关注的是算法的变化。而不关注领域实体的变化。变化的因素是算法行为的变化。

可以任意动态的添加和删除算法类。符合开闭原则。

优点：

1，策略模式，提供管理算法簇的方法。恰当使用继承，可以把公共的代码移到父类中去。避免代码的重复。

2，使用策略类，避免多重条件的转移语句，使代码看起来更优雅。耦合性降低。

缺点：

1，客户端必须清楚，知道所有的策略类。

2，策略模式会造成很多策略类。有时会使代码臃肿和数量庞大。

策略模式的的核心：

行为的单一变化，每个行为都封装在不同的类中。