设计模式之"策略模式"

一.概念

策略模式：它定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法的变化不会影响到使用算法的客户。



二.UML





Context(应用场景)，持有Strategry对象的引用。
Context能动态指定Strategry具体的实现。
Context要使用Strategry提供的算法。
Strategry(抽象策略类)，定义了算法的骨架。
ConcreteStrategryA-C实现类，提供算法的具体实现。

三.实例分析

铁道部现需要一个订票网站，于是对外招标，有许多公司都参与了竞标，它们都有能力做出一个像样的网站出来。因为铁道部有钱撒，所以打算搞两三个系统出来，对外开放一个给大家订票，另外两个保留，一旦发现第一个系统不对劲，立马使用第二个系统。从这个里面，我们可以抽象出这样的几个类：

ProjectPublisher：项目发布者，铁道部。

ProjectTeamA-C：各个竞标公司。



ProjectPublisher:

Java代码


package com.zzy.strategry;



/**

* 项目发布者-铁道部

* @author eason

*/

public class ProjectPublisher {



//持有ProjectTeam对象的引用

private ProjectTeam projectTeam;



public ProjectPublisher(ProjectTeam projectTeam) {

this.projectTeam = projectTeam;

}

//使用ProjectTeam提供的算法

public void publishProject() {

projectTeam.finshProject();

}

//能动态指定ProjectTeam具体的实现

public void setProjectTeam(ProjectTeam projectTeam) {

this.projectTeam = projectTeam;

}



}



ProjectTeam

Java代码


package com.zzy.strategry;

/**

* 抽象策略类

* @author eason

*/

public abstract class ProjectTeam {



//定义了算法的骨架

public abstract void finshProject();



}



ProjectTeamA

Java代码


package com.zzy.strategry;

/**

* 策略实现类-每个竞标公司

* @author eason

*/

public class ProjectTeamA extends ProjectTeam {



//提供算法的具体实现

public void finshProject() {

//TODO

System.out.println("ProjectTeamA完成这个网站");

}



}



TestStrategry

Java代码


package com.zzy.strategry;

/**

* 测试类-client

* @author eason

*/

public class TestStrategry {



public static void main(String[] args) {

ProjectTeamA pa = new ProjectTeamA();

ProjectTeamB pb = new ProjectTeamB();

//首先ATeam的系统

ProjectPublisher pub = new ProjectPublisher(pa);

pub.publishProject();

//媒体报道现在使用的订票网站，经常瘫痪

//于是乎换了一个系统

pub.setProjectTeam(pb);

pub.publishProject();

}



}



四.使用场景

一件事情，有很多方案可以实现。
我可以在任何时候，决定采用哪一种实现。
未来可能增加更多的方案。
策略模式让方案的变化不会影响到使用方案的客户。
在铁道部的例子中，我强调的“网站瘫痪”是为了来说明上面的第2点。实际上，对购票者来说，使用哪个系统都能够到票，这个“够到票”就叫没有影响到使用方案的用户。

五.使用感受

方便client使用，用户只需要拿到Context就能完成所有事情。
OO原则中的组合优于继承。
OO原则中的封装性。

注：以上内容来自http://zy19982004.iteye.com/blog/1405442

再开看个例子：

class processor{
                           pubilic String name（）{
                             return getClass（）.getSimpleName（）；
}           
                     Object process（Object input）{return input}            
}
                         class Upcase extends Processor{
                       String process（Object input）{
                           return （（String）input）.toUpperCase（）；
} 
}
  class Downcase extends Processor{
                       String process（Object input）{
                           return （（String）input）.toLowerCase（）；
} 
}
public class Apply{
public static void process(Process p, Object s){
      System.out.println("Using Processor"+p.name());
          System.out.println(p.process(s));
}
       public static String s="a b c ";
     public static void main(String[] args){
    process(new Upcase(),s);
    process(new Downcase(),s);
}
}
Using Processor Upcase
A B C
Using Processor Downcase
a b c

本例中，创建一个能够根据所传递的参数对象的不同而具有不同行为的方法，就是“策略模式”。这类方法中包含所要执行的算法中固定不变的部分，而“策略”包含变化的部分。策略就是传递进去的参数对象，它包含要执行的代码。这里，Processor对象就是一个策略，在main（）中可以看到有二种不同的策略应用到了String类型的s对象上。


总结：代码可以多种多样，关键是抓住策略模式的的思想，一件事情可以由不同的人完成。