JAVA设计模式四策略模式

                                          JAVA设计模式四策略模式

策略模式：它定义了算法家族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的客户。

策略模式是一种定义一系列算法的方法，从概念上来看，所有这些算法完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合。

结构：  Strategy: 定义所有支持的算法的公共接口抽象类.

              ConcreteStrategy: 封装了具体的算法或行为，继承于Strategy

              Context: 用一个ConcreteStrategy来配置，维护一个对Strategy对象的引用。

策略的抽象算法类

public  abstract  class  Strategy{ 

   //算法方法 

   public abstract void AlgorithmInterface();     //每个具体的策略类继承抽象的策略类    重写该算法方法

}

具体算法A          继承算法类  重写算法方法

public class ConcreteStrategyA extendsStrategy{ 

   @Override 

   public void AlgorithmInterface() { 

       System.out.println("算法A实现!"); 

   } 

}  

具体算法B   

public class ConcreteStrategyB extends Strategy{ 

    @Override 

    public voidAlgorithmInterface() { 

       System.out.println("算法B实现!"); 

    } 

}

具体算法C:

public class ConcreteStrategyC extendsStrategy{ 

   @Override 

   public void AlgorithmInterface() { 

       System.out.println("算法C实现!"); 

   } 

} 

定义Context类维护对Strategy对象的引用        【上下文】

public class Context {       //定义上下文类

   private Strategy mStrategy;      

   public Context(Strategy strategy){       //运用多态  传入具体的策略类

       this.mStrategy = strategy; 

   } 

   /** 

    * 上下文接口 

    */ 

   public void ContextInterface(){          //具体的策略类会调用相应的具体方法

       mStrategy.AlgorithmInterface(); 

   } 

} 

客户端代码：

public class MainClient { 

   private static Context context; 

   public static void main(String[] args) { 

     context = new Context(new ConcreteStrategyA()); //创建上下文类传入具体的策略对象

       context.ContextInterface();                         //策略A调用相应的算法

          

       context = new Context(new ConcreteStrategyB()); 

       context.ContextInterface(); 

         

       context = new Context(new ConcreteStrategyC()); 

       context.ContextInterface(); 

   }     

}

上述单纯的策略模式重复建立Context     要客户端去判断选择创建哪个策略对象 

改进策略模式和简单工厂相结合

public class Context {       //定义上下文类

   private Strategy mStrategy;      

   public Context(int   type){        //不是传入具体的策略类     而是传入类型  

       switch(type){

         case 1:

           ConcreteStrategyA  a=new ConcreteStrategyA  ();

            mStrategy=a;

            break:

        case 2:

           ConcreteStrategyB  b=new ConcreteStrategyB  ();

            mStrategy=b;

            break:

        case 3:

              ConcreteStrategyC  c=new ConcreteStrategyC  ();

              mStrategy=c;

            break:

      }

  } 

   /** 

    * 上下文接口 

    */ 

   public void ContextInterface(){          //具体的策略类会调用相应的具体方法

       mStrategy.AlgorithmInterface(); 

   } 

} 

创建一个工厂类Context就可以使用了