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 = 0;
        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 = 0;
        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(300,100);
            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类中聚合了产品类,没有依赖关系