设计模式之策略模式详解

策略模式

1）概述

1.概念

每一个封装算法的类被称为一种策略(Strategy)。

2.定义

定义一系列算法类，将每一个算法封装起来，并让它们可以相互替换，策略模式让算法独立于使用它的客户而变化。

3.方案

将算法的定义放在专门的策略类中，每一个策略类封装了一种实现算法，使用算法的环境类针对抽象策略类进行编程，在出现新的算法时，只需要增加一个新的具体策略类即可。

4.结构图

5.角色

Context（环境类）：环境类是使用算法的角色，它在解决某个问题时可以采用多种策略，在环境类中维持一个对抽象策略类的引用实例，用于定义所采用的策略。

Strategy（抽象策略类）：为所支持的算法声明了抽象方法，是所有策略类的父类，它可以是抽象类、具体类或接口，环境类通过抽象策略类中声明的方法在运行时调用具体策略类中实现的算法。

ConcreteStrategy（具体策略类）：实现了在抽象策略类中声明的算法，在运行时，具体策略类将覆盖在环境类中定义的抽象策略类对象，使用一种具体的算法实现某个业务处理。

6.代码实现

抽象策略类

复制代码

abstract class AbstractStrategy {
    public abstract void algorithm(); //声明抽象算法
}

具体策略类

复制代码

public class ConcreteStrategyA extends AbstractStrategy {
    //算法的具体实现
    public void algorithm() {
       //算法A
    }
}

Context类

复制代码

public class Context {
		private AbstractStrategy strategy; //维持一个对抽象策略类的引用
 
    public void setStrategy(AbstractStrategy strategy) {
        this.strategy= strategy;
    }
 
    //调用策略类中的算法
    public void algorithm() {
        strategy.algorithm();
    }
}

客户端类

复制代码

......
Context context = new Context();
AbstractStrategy strategy;
strategy = new ConcreteStrategyA(); //可在运行时指定类型
context.setStrategy(strategy);
context.algorithm();
......

2）完整解决方案

1.结构图

MovieTicket充当环境类角色，Discount充当抽象策略角色，StudentDiscount、 ChildrenDiscount 和VIPDiscount充当具体策略角色。

2.代码实现

复制代码

//电影票类：环境类
public 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);
}
 
//学生票折扣类：具体策略类
public class StudentDiscount implements Discount {
	public double calculate(double price) {
		System.out.println("学生票：");
		return price * 0.8;
	}
} 
 
//儿童票折扣类：具体策略类
public class ChildrenDiscount implements Discount {
	public double calculate(double price) {
		System.out.println("儿童票：");
		return price - 10;
	}
} 
 
//VIP会员票折扣类：具体策略类
public class VIPDiscount implements Discount {
	public double calculate(double price) {
		System.out.println("VIP票：");
		System.out.println("增加积分！");
		return price * 0.5;
	}
}

客户端类

复制代码

public 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 ChildrenDiscount(); 
		mt.setDiscount(discount); //注入折扣对象
		
		currentPrice = mt.getPrice();
		System.out.println("折后价为：" + currentPrice);
	}
}

3）总结

1.优点

可以在不修改原有系统的基础上选择算法或行为，也可以灵活地增加新的算法或行为。
可以避免多重条件选择语句。
提供了一种算法的复用机制，可以方便地复用这些策略类。

2.缺点

客户端必须知道所有的策略类，并自行决定使用哪一个策略类。
将造成系统产生很多具体策略类，任何细小的变化都将导致系统要增加一个新的具体策略类。
无法在客户端同时使用多个策略类。

3.适用场景

系统需要动态地在几种算法中选择一种。
对象有很多行为，如果不用恰当的模式，则只能使用多重条件选择语句来实现。
不希望客户端知道复杂的、与算法相关的数据结构，在具体策略类中封装算法与相关的数据结构，可以提高算法的保密性与安全性。