行为型模式——策略模式

体现原则：

1）依赖倒置

2）合成复用

解析：

实例：

初始设计：

//电影票类
class MovieTicket {
    
        private double price; //电影票价格
        private String type; //电影票类型
    
        public void setPrice(double price) {
                this.price = price;
        }
    
        public void setType(String type) {
                this.type = type;
        }
    
        public double getPrice() {
                return this.calculate();
        }
    
        //计算打折之后的票价
        public double calculate() {
                //学生票折后票价计算
                if(this.type.equalsIgnoreCase("student")) {
                        System.out.println("学生票：");
                        return this.price * 0.8;
                }
    
                //儿童票折后票价计算
                else if(this.type.equalsIgnoreCase("children") && this.price >= 20 ) {
                        System.out.println("儿童票：");
                        return this.price - 10;
                }
    
                //VIP票折后票价计算
                else if(this.type.equalsIgnoreCase("vip")) {
                        System.out.println("VIP票：");
                        System.out.println("增加积分！");
                        return this.price * 0.5;
                }
    
                else {
                        return this.price; //如果不满足任何打折要求，则返回原始票价
                }
    
        }
    
}

客户端测试代码：

class Client {
    public static void main(String args[]) {
        MovieTicket mt = new MovieTicket();
        double originalPrice = 60.0; //原始票价
        double currentPrice; //折后价
        mt.setPrice(originalPrice);
        System.out.println("原始价为：" + originalPrice);
        System.out.println("---------------------------------");
        mt.setType("student"); //学生票
        currentPrice = mt.getPrice();
        System.out.println("折后价为：" + currentPrice);
        System.out.println("---------------------------------");
        mt.setType("children"); //儿童票
        currentPrice = mt.getPrice();
        System.out.println("折后价为：" + currentPrice);
        }
}

此时，我想再加一种打折方式，那么我就不得不对 MovieTicket 类的代码进行修改，这违背了开闭原则。同时，可以看到具体实现写在了 MovieTicket 类里，也就是针对实现编程。这违背了依赖倒置原则，事实上我们应该针对接口编程，细节依赖于抽象。将抽象策略类作为 MovieTicket 类的属性，同时将具体策略类作为抽象策略类的实现。此外，如果不使用策略模式，那么使用算法的环境类就可能会有一些子类，每一个子类提供一种不同的算法。但是，这样一来算法的使用就和算法本身混在一起，不符合“单一职责原则”，决定使用哪一种算法的逻辑和该算法本身混合在一起，从而不可能再独立演化而且使用继承无法实现算法或行为在程序运行时的动态切换。

由于组合或聚合关系可以将已有的对象（也可称为成员对象）纳入到新对象中，使之成为新对象的一部分，因此新对象可以调用已有对象的功能，这样做可以使得成员对象的内部实现细节对于新对象不可见，所以这种复用又称为“黑箱”复用，相对继承关系而言，其耦合度相对较低，成员对象的变化对新对象的影响不大，可以在新对象中根据实际需要有选择性地调用成员对象的操作；合成复用可以在运行时动态进行，新对象可以动态地引用与成员对象类型相同的其他对象。

本题采用策略模式后的UML图：

代码实现：

//电影票类：环境类
class MovieTicket {
        private double price;
        private Discount discount; //维持一个对抽象折扣类的引用
        public void setPrice(double price) {
                this.price = price;
        }
        //注入一个折扣类对象
        public void setDiscount(Discount discount) {
                this.discount = discount;
        }
        public double getPrice() {
                //调用折扣类的折扣价计算方法
                return discount.calculate(this.price);
        }
}

//折扣类：抽象策略类
interface Discount {
        public double calculate(double price);
}

//学生票折扣类：具体策略类
class StudentDiscount implements Discount {
        public double calculate(double price) {
                System.out.println("学生票：");
                return price * 0.8;
        }
}

//儿童票折扣类：具体策略类
class ChildrenDiscount implements Discount {
        public double calculate(double price) {
                System.out.println("儿童票：");
                return price - 10;
        }
}

//VIP会员票折扣类：具体策略类
class VIPDiscount implements Discount {
        public double calculate(double price) {
                System.out.println("VIP票：");
                System.out.println("增加积分！");
                return price * 0.5;
        }
}

客户端测试：

class Client {
        public static void main(String args[]) {
                MovieTicket mt = new MovieTicket();
                double originalPrice = 60.0;
                double currentPrice;
                mt.setPrice(originalPrice);
                System.out.println("原始价为：" + originalPrice);
                System.out.println("---------------------------------");
                Discount discount;
                discount = new StudentDiscount();
                mt.setDiscount(discount); //注入折扣对象
                currentPrice = mt.getPrice();
                System.out.println("折后价为：" + currentPrice);
            }
}

运行结果：

反思：

(1) 客户端必须知道所有的策略类，并自行决定使用哪一个策略类。这就意味着客户端必须理解这些算法的区别，以便适时选择恰当的算法。换言之，策略模式只适用于客户端知道所有的算法或行为的情况。

(2) 策略模式将造成系统产生很多具体策略类，任何细小的变化都将导致系统要增加一个新的具体策略类。

(3) 无法同时在客户端使用多个策略类，也就是说，在使用策略模式时，客户端每次只能使用 一个策略类，不支持使用一个策略类完成部分功能后再使用另一个策略类来完成剩余功能的情况。