Java学习笔记——设计模式之二.策略模式

明确是王道

　　　　——Clean Code

类图：

先定义策略类

 package cn.no2.strategy;

 public abstract class Strategy {

     //省略属性
     //算法方法
     public abstract void algrithmInterface();
 }

在定义若干策略子类

 package cn.no2.strategy;

 public class ConcreteStrategyA extends Strategy {

     @Override
     public void algrithmInterface() {
         // TODO Auto-generated method stub
         System.out.println("算法A实现");
     }

 }
 public class ConcreteStrategyB extends Strategy {

     @Override
     public void algrithmInterface() {
         // TODO Auto-generated method stub
         System.out.println("算法B实现");
     }

 }
 public class ConcreteStrategyC extends Strategy {

     @Override
     public void algrithmInterface() {
         // TODO Auto-generated method stub
         System.out.println("算法C实现");
     }

 }

最后定义业务逻辑"上下文类"

 package cn.no2.strategy;

 public class BizContext {

     Strategy strategy = null;

     public BizContext(String type) {

         switch (type) {
         case "策略A":
             strategy= new ConcreteStrategyA();
             break;
         case "策略B":
             strategy= new ConcreteStrategyB();
             break;
         case "策略C":
             strategy= new ConcreteStrategyC();
             break;
         }
     }

     public void ContextInterface(){
         strategy.algrithmInterface();
     }
 }

测试类

 package cn.no2.strategy;

 public class _Text {

     public static void main(String[] args) {
         BizContext biz;
         biz = new BizContext("策略A");
         biz.ContextInterface();
         biz = new BizContext("策略B");
         biz.ContextInterface();
         biz = new BizContext("策略C");
         biz.ContextInterface();
     }
 }

诚然,上面的程序只是明确了框架,并没有任何实际的业务逻辑.下面来写个需求

输入单价、数量、计价方式，其中计价方式就是策略：

策略1：正常收费

策略2：打X折

策略3：满X元减Y元

输出结果。

上代码：

Strategy类:

 package cn.no2.strategy.instance;

 public abstract class Strategy {

     private double unitPrice;
     private int count;

     public double getUnitPrice() {
         return unitPrice;
     }

     public void setUnitPrice(double unitPrice) {
         this.unitPrice = unitPrice;
     }

     public int getCount() {
         return count;
     }

     public void setCount(int count) {
         this.count = count;
     }

     //计算结果,返回double值
     public abstract double algrithmInterface();

 }

其子类:

 package cn.no2.strategy.instance;

 public class NomalStrategy extends Strategy {

     @Override
     public double algrithmInterface() {
         // 使用清晰规范的代码,定义变量,计算,返回
         double result = ;
         result = this.getUnitPrice()*this.getCount();
         return result;
     }

 }
 public class DiscountStrategy extends Strategy {

     private double discount;

     public DiscountStrategy(double discount) {
         super();
         this.discount = discount;
     }

     @Override
     public double algrithmInterface() {
         // 这里重写方法不能传入参数,所以需要定义该子类特有的属性,折扣
         double result = ;
         result = this.getUnitPrice()*this.getCount()*discount;
         return result;
     }

 }
 public class FullReduceStrategy extends Strategy {

     double full;
     double reduction;

     public FullReduceStrategy(double full, double reduction) {
         super();
         this.full = full;
         this.reduction = reduction;
     }

     @Override
     public double algrithmInterface() {
         // TODO Auto-generated method stub
         double result = this.getUnitPrice()*this.getCount();
         if (result >= full) {
             result -= reduction;
         }
         return result;
     }

 }

业务逻辑类:

 package cn.no2.strategy.instance;

 public class BizContext {

     private Strategy strategy = null;

     public BizContext(String type) {

         switch (type) {
         case "正常收费":
             strategy= new NomalStrategy();
             break;
         case "打8.5折":
             strategy= new DiscountStrategy(8.5);
             break;
         case "满300减100":
             strategy= new FullReduceStrategy(,);
             break;
         }
     }
     //彻底封装Strategy类
     public void initStrategy(double unitPrice,int count) {
         strategy.setUnitPrice(unitPrice);
         strategy.setCount(count);
     }
     //这里实现的对strategy的封装,调用者只调用BizContext自己的方法
     public double ContextInterface(){
         return strategy.algrithmInterface();
     }
 }

Test类:

 package cn.no2.strategy.instance;

 import java.util.Scanner;

 public class _Text {

     public static void main(String[] args) {
         Scanner sc = new Scanner(System.in);
         System.out.println("请输入单价:");
         double unitPrice = sc.nextDouble();
         System.out.println("请输入数量:");
         int count = sc.nextInt();
         System.out.println("请输入策略:(正常收费,打8.5折,满300减100)");//这里如果改动,只需增加BizContext的业务逻辑
         String strategy = sc.next();
         BizContext biz = new BizContext(strategy);
         biz.initStrategy(unitPrice,count);
         double result = biz.ContextInterface();
         System.out.println("总价是:"+result);
         sc.close();
     }
 }

以上是策略模式的实际应用

策略模式与简单工厂对比:

简单工厂模式：客户端传一个条件进工厂类，工厂类根据条件创建相应的产品类对象，客户端使用该产品类对象.工厂类依赖产品类

策略模式：客户端创建一个Context类对象,并通过传入参数使用该对象。Context类中聚合了产品类,没有依赖关系