设计模式

前言:

　　先不管模式, 把他和他的名字都忘了, 来看看问题 和 设计思路. 为啥要这么做. 

场景:

　　有一家店铺, 里面有一个售货员, 售货员当然是要卖东西的啦, 客户进来买完东西, 找售货员结账, 那售货员得知道一共多少钱吧?

一. 初步设计

　　商品类:

package org.elvin.strategy;

/***/
public class Goods {
    /**
     * 商品名
     */
    private String name;

    /**
     * 商品价格
     */
    private Long Price;

    public Goods() { }

    public Goods(String name, Long price) {
        this.name = name;
        Price = price;
    }

    //region getter / setter
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Long getPrice() {
        return Price;
    }

    public void setPrice(Long price) {
        Price = price;
    }
    //endregion
}

由于价格我使用的是 Long 类型, 所以, 要有一个转换输出的方法.

package org.elvin.strategy;

import java.text.MessageFormat;

public class MoneyUtils {
    public static String getYuan(Long money){
        Long yuan = money / 100;
        Long jiao = money % 100 /  10;
        Long fen = money % 10;

        return MessageFormat.format("{0}.{1}{2}", yuan, jiao , fen );
    }
}

售货员:

package org.elvin.strategy;

import org.elvin.strategy.calculator.*;
import org.junit.Test;

import java.util.ArrayList;
import java.util.List;

/**
 * 环境角色(Context)*/
public class Seller {

    /**
     * 姓名
     */
    private String name;

    /**
     * 编号
     */
    private String code;

    //region getter / setter
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }
    //endregion

    /**
     * 售卖商品
     */
    public void sellGoods(List<Goods> goods){
        Long sum = 0L;
        for (Goods good : goods) {
            sum += good.getPrice();
        }
        System.out.println("应付款: " + MoneyUtils.getYuan(sum) + " 元");
    }

    @Test
    public void func1(){
        List<Goods> goods = new ArrayList<>();
        goods.add(new Goods("泡面", 550L));
        goods.add(new Goods("泡面", 550L));
        goods.add(new Goods("泡面", 550L));
        goods.add(new Goods("火腿", 150L));
        goods.add(new Goods("火腿", 150L));
        goods.add(new Goods("火腿", 150L));
        goods.add(new Goods("鸡蛋", 70L));
        goods.add(new Goods("鸡蛋", 70L));
        goods.add(new Goods("鸡蛋", 70L));
        goods.add(new Goods("饼干", 250L));
        goods.add(new Goods("辣条", 300L));

        sellGoods(goods);
    }
}

来看一下计算结果:

得到结果了, 没啥毛病, 挺好. 

今天老板过生日, 突然想到, 要不要再店里搞个活动, 来个优惠活动, 有些商品减价销售. 

明天老板娘过生日, 老板娘说, 老娘高兴, 你减价销售, 明天我来个免单销售.

那现在咋办呢? 明天过后, 价格肯定又要恢复到正常价格.  what the fuck! 

Seller类写死了, 难道我在里面加几个计算方法? 

加进去貌似可以解决当下问题, 但是, 后天如果老板的老丈人过生日呢? 咋搞?

Ok, 到这里, 差不多, 需要请出今天的大神 : 策略模式. 让他来帮我们解决这个问题吧.

二. 设计改造

对于售货员来说, 她必须知道, 今天该怎么计算价格, 是优惠还是不优惠, 或者是满多少钱, 送东西什么的. 

那么, 将这些优惠或者说价格的计算方法抽象出来, 成为一个接口或者抽象类. 

让优惠或者不优惠实现或者继承他.

实现方式:

这里, 我将他抽象为一个接口

package org.elvin.strategy.calculator;

import org.elvin.strategy.Goods;

import java.util.List;

/**
 * 抽象策略角色(Strategy)
 * 优惠接口
*/
public interface PreferentialPrice {
    public void getPrice(List<Goods> goods);
}

PreferentialPrice 需要作为一个属性,出现在 Seller 类中.

在Seller中加入

    /**
     * 计算优惠后的价格
     * 抽象角色, 次角色给出所有具体策略类所需的接口
     */
    private PreferentialPrice preferentialPrice;

    public PreferentialPrice getPreferentialPrice() {
        return preferentialPrice;
    }

    public void setPreferentialPrice(PreferentialPrice preferentialPrice) {
        this.preferentialPrice = preferentialPrice;
    }

这里提供三种计算方式:

1. 正常方式

/**
 * 具体策略角色(ConcreteStrategy)
*/
public class NoPreferential implements PreferentialPrice {

    @Override
    public void getPrice(List<Goods> goods) {
        Long sum = 0L;
        for (Goods good : goods) {
            sum += good.getPrice();
        }
        System.out.println("应付款: " + MoneyUtils.getYuan(sum) + " 元");
    }
}

2. 免单方式

/**
 * 具体策略角色(ConcreteStrategy)
*/
public class Free implements PreferentialPrice {
    @Override
    public void getPrice(List<Goods> goods) {
        System.out.println("免单, 不要钱 !");
    }
}

3. 部分优惠方式

/**
 * 具体策略角色(ConcreteStrategy)
*/
public class ReduceSomeGoods implements PreferentialPrice {

    @Override
    public void getPrice(List<Goods> goods) {
        Long sum = 0L;
        for (Goods good : goods) {
            switch (good.getName()) {
                case "泡面":
                    sum += good.getPrice() - 50L;
                    break;

                case "火腿":
                    sum += good.getPrice() - 20L;
                    break;

                case "鸡蛋":
                    sum += good.getPrice() - 10L;
                    break;

                default:
                    sum += good.getPrice();
                    break;
            }
        }
        System.out.println("应付款: " + MoneyUtils.getYuan(sum) + " 元");
    }
}

　　

 将Seller类中, 计算的方法修改一下:

    public void sellGoods(List<Goods> goods){
        if(preferentialPrice == null){
            setPreferentialPrice(new NoPreferential());
        }
        preferentialPrice.getPrice(goods);
    }

在计算的时候, 如果没有传入优惠, 则默认使用无优惠方式

再看测试方法:

    @Test
    public void func1(){
        List<Goods> goods = new ArrayList<>();
        goods.add(new Goods("泡面", 550L));
        goods.add(new Goods("泡面", 550L));
        goods.add(new Goods("泡面", 550L));
        goods.add(new Goods("火腿", 150L));
        goods.add(new Goods("火腿", 150L));
        goods.add(new Goods("火腿", 150L));
        goods.add(new Goods("鸡蛋", 70L));
        goods.add(new Goods("鸡蛋", 70L));
        goods.add(new Goods("鸡蛋", 70L));
        goods.add(new Goods("饼干", 250L));
        goods.add(new Goods("辣条", 300L));

        setPreferentialPrice(new Free());
        sellGoods(goods);
        System.out.println("-----------------------");
        setPreferentialPrice(new ReduceSomeGoods());
        sellGoods(goods);
        System.out.println("-----------------------");
        setPreferentialPrice(new NoPreferential());
        sellGoods(goods);
    }

结果:

　　

策略模式作为一种对象行为模式, 在这里应该还是体现到了吧.

那总结一下?给个不容易懂得(网上抄的):

　　策略模式属于对象的行为模式。其用意是针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。

说的比较抽象, 来个具体的吧:

　　一帅哥喜欢约妹子, 那咋约出来呢? 不是所有的妹子都喜欢吃饭看电影吧. 那针对不同的妹子, 使用不同的方法来约. 约喜欢看电影的妹子看电影, 约喜欢吃小吃的妹子吃小吃.

那吃饭, 看电影, 吹海风...... 等等, 这些手段, 目的都是为了让妹子做他女朋友(这里不讨论时间). 目的不变, 手段层出不穷. 这些方法, 就可以理解为不同的 strategy. 

 

通过上面的例子, 可以看出, 具体的算法与算法之间没有依赖关系, 都是平等的(平等性), 可以相互替换的. 那在运行的时候, 每次都只能使用一种(唯一性).