设计模式实战13--行为型--策略模式
来源:互联网 发布:沃伦夫妇纪录片 知乎 编辑:程序博客网 时间:2024/06/06 03:04
策略模式(Strategy)定义:策略模式定义了一系列的算法,并将每一个算法封装起来,而且使它们还可以相互替换。
策略模式让算法独立于使用它的客户而独立变化。
策略模式结构图:
策略模式解析:
Context(应用场景):
1、需要使用ConcreteStrategy提供的算法。
2、 内部维护一个Strategy的实例。
3、 负责动态设置运行时Strategy具体的实现算法。
4、负责跟Strategy之间的交互和数据传递。
Strategy(抽象策略类):
1、 定义了一个公共接口,各种不同的算法以不同的方式实现这个接口,Context使用这个接口调用不同的算法,一般使用接口或抽象类实现。
ConcreteStrategy(具体策略类):
2、 实现了Strategy定义的接口,提供具体的算法实现。
策略模式实战1:
package org.leiwen.dp.action.stragety.constants;
import java.util.Map;
//常量接口
public interface ConstantProvider {
public interface ConstantProvider {
Map<String, String> loadConfiguration();
}
}
package org.leiwen.dp.action.stragety.constants.impl;
import java.io.File;
import java.io.InputStream;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.io.InputStream;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.leiwen.dp.action.stragety.constants.ConfigurationException;
import org.leiwen.dp.action.stragety.constants.ConstantProvider;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.leiwen.dp.action.stragety.constants.ConfigurationException;
import org.leiwen.dp.action.stragety.constants.ConstantProvider;
public class XmlConstantProvider implements ConstantProvider {
private String configFileName;
private Map<String, String> config = new HashMap<String, String>();
public XmlConstantProvider(String fileName) {
this.configFileName = fileName;
}
this.configFileName = fileName;
}
public XmlConstantProvider() {
}
@Override
public Map<String, String> loadConfiguration() {
public Map<String, String> loadConfiguration() {
// 使用SAXReader解析算法
SAXReader saxReader = new SAXReader();
ClassLoader classLoader = this.getClass().getClassLoader();
InputStream inputStream = classLoader
.getResourceAsStream(configFileName);
SAXReader saxReader = new SAXReader();
ClassLoader classLoader = this.getClass().getClassLoader();
InputStream inputStream = classLoader
.getResourceAsStream(configFileName);
if (inputStream == null) {
throw new ConfigurationException("intputStream == null");
}
throw new ConfigurationException("intputStream == null");
}
Document doc = null;
try {
doc = saxReader.read(inputStream);
Element root = doc.getRootElement();
List<Element> elements = root.elements("constant");
try {
doc = saxReader.read(inputStream);
Element root = doc.getRootElement();
List<Element> elements = root.elements("constant");
for (Element e : elements) {
String name = e.attributeValue("name");
String value = e.attributeValue("value");
if (name != null && value != null) {
config.put(name, value);
}
}
} catch (DocumentException e) {
throw new ConfigurationException(e);
}
String name = e.attributeValue("name");
String value = e.attributeValue("value");
if (name != null && value != null) {
config.put(name, value);
}
}
} catch (DocumentException e) {
throw new ConfigurationException(e);
}
return config;
}
}
}
package org.leiwen.dp.action.stragety.constants.impl;
import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;
import java.util.Set;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;
import java.util.Set;
import org.leiwen.dp.action.stragety.constants.ConfigurationException;
import org.leiwen.dp.action.stragety.constants.ConstantProvider;
import org.leiwen.dp.action.stragety.constants.ConstantProvider;
//常量提供者的实现,读取属性文件的方式
public class PropertiesConstantProvider implements ConstantProvider {
public class PropertiesConstantProvider implements ConstantProvider {
public static final String FILE_NAME = "constants.properties";
private Map<String, String> context = new HashMap<String, String>();
@Override
public Map<String, String> loadConfiguration() {
Properties props = new Properties();
public Map<String, String> loadConfiguration() {
Properties props = new Properties();
InputStream in = this.getClass().getClassLoader()
.getResourceAsStream(FILE_NAME);
.getResourceAsStream(FILE_NAME);
try {
props.load(in);
} catch (IOException e) {
throw new ConfigurationException(e);
}
props.load(in);
} catch (IOException e) {
throw new ConfigurationException(e);
}
Set<Entry<Object, Object>> entrys = props.entrySet();
for (Entry<Object, Object> entry : entrys) {
String name = (String) entry.getKey();
String value = (String) entry.getValue();
if (name != null && value != null) {
context.put(name, value);
}
}
return context;
}
}
for (Entry<Object, Object> entry : entrys) {
String name = (String) entry.getKey();
String value = (String) entry.getValue();
if (name != null && value != null) {
context.put(name, value);
}
}
return context;
}
}
package org.leiwen.dp.action.stragety.constants.impl;
import java.util.Map;
import org.leiwen.dp.action.stragety.constants.ConstantProvider;
//自定义常量提供器
public class CustomConstantProvider implements ConstantProvider {
public class CustomConstantProvider implements ConstantProvider {
@Override
public Map<String, String> loadConfiguration() {
// 根据自己的配置格式,实现相应的算法
return null;
}
public Map<String, String> loadConfiguration() {
// 根据自己的配置格式,实现相应的算法
return null;
}
}
package org.leiwen.dp.action.stragety.constants;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CopyOnWriteArrayList;
//常量管理器
public class ConstantManager {
public class ConstantManager {
// 内部封装了所有的容器加载器ContainerProvider
private List<ConstantProvider> providers = new CopyOnWriteArrayList<ConstantProvider>();
private List<ConstantProvider> providers = new CopyOnWriteArrayList<ConstantProvider>();
// 保存所有的常量
private Map<String, String> context = new HashMap<String, String>();
private Map<String, String> context = new HashMap<String, String>();
// 增加常量提供器
public void addConfigurationProvider(ConstantProvider provider) {
providers.add(provider);
}
public void addConfigurationProvider(ConstantProvider provider) {
providers.add(provider);
}
// 初始化过程,实际上就是将各种各样的配置元素,无论是XML形式还是Properties文件形式(甚至可能是其它自定义的配置形式)
// 转化为Java对象的过程。
public void init() {
// 不同的ConstantProvider之间并没有依赖关系。这一点告诉我们,所有的常量加载器对于我们而言是一视同仁的。
for (ConstantProvider provider : providers) {
Map<String, String> map;
try {
map = provider.loadConfiguration();
if (map != null) {
context.putAll(map);
}
} catch (Exception e) {
e.printStackTrace();
}
// 转化为Java对象的过程。
public void init() {
// 不同的ConstantProvider之间并没有依赖关系。这一点告诉我们,所有的常量加载器对于我们而言是一视同仁的。
for (ConstantProvider provider : providers) {
Map<String, String> map;
try {
map = provider.loadConfiguration();
if (map != null) {
context.putAll(map);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
// 打印常量
public void printConstants() {
for (Map.Entry<String, String> entry : context.entrySet()) {
String name = entry.getKey();
String value = entry.getValue();
System.out.println(name + "=" + value);
}
}
}
public void printConstants() {
for (Map.Entry<String, String> entry : context.entrySet()) {
String name = entry.getKey();
String value = entry.getValue();
System.out.println(name + "=" + value);
}
}
}
package org.leiwen.dp.action.stragety.constants;
import org.dom4j.DocumentException;
public class ConfigurationException extends RuntimeException {
public ConfigurationException() {
super();
}
super();
}
public ConfigurationException(String message, Throwable cause) {
super(message, cause);
}
super(message, cause);
}
public ConfigurationException(String message) {
super(message);
}
super(message);
}
public ConfigurationException(Throwable cause) {
super(cause);
}
super(cause);
}
}
2个配置文件(都位于类路径下)
constants.properties
name=fans
school=wust
school=wust
constants.xml
<constants>
<constant name="fans" value="leiwen" />
<constant name="fans" value="leiwen" />
<constant name="fanssoft" value="软林至尊,fans同盟。" />
</constants>
package org.leiwen.dp.action.stragety.constants;
import org.leiwen.dp.action.stragety.constants.impl.PropertiesConstantProvider;
import org.leiwen.dp.action.stragety.constants.impl.XmlConstantProvider;
import org.leiwen.dp.action.stragety.constants.impl.XmlConstantProvider;
/**
* @author 雷文 2012-3-24
*/
public class StragetyTest {
* @author 雷文 2012-3-24
*/
public class StragetyTest {
//
public static void main(String[] args) {
ConstantProvider xmlProvider = new XmlConstantProvider("constants.xml");
ConstantProvider propProvider = new PropertiesConstantProvider();
ConstantManager manager = new ConstantManager();
manager.addConfigurationProvider(xmlProvider);
manager.addConfigurationProvider(propProvider);
manager.init();
manager.printConstants();
public static void main(String[] args) {
ConstantProvider xmlProvider = new XmlConstantProvider("constants.xml");
ConstantProvider propProvider = new PropertiesConstantProvider();
ConstantManager manager = new ConstantManager();
manager.addConfigurationProvider(xmlProvider);
manager.addConfigurationProvider(propProvider);
manager.init();
manager.printConstants();
}
}
程序运行结果:
策略模式实战2(大话设计模式书上的例子):
package org.leiwen.dp.action.stragety.basic;
//现金收费抽象类
public abstract class CashSuper {
// 使用枚举类型表示收费类型
public enum PayType {
CASH_NORMAL, CASH_RETURN, CASH_REBATE
};
// 现金收取抽象类的抽象方法,收取现金,参数为原价,返回值为当前价
public abstract double acceptCash(double money);
}
package org.leiwen.dp.action.stragety.basic;
/**
* 正常收费子类
*/
public class CashNormal extends CashSuper {
//正常收费,原价返回
public double acceptCash(double money) {
return money;
}
}
/**
* 打折收费子类
* @author Administrator
*
*/
public class CashRebate extends CashSuper {
private double moneyRebate = 1;
//打折收费,初始化时,需要输入折扣率,如八折,就是0.8
public CashRebate(double moneyRebate) {
this.moneyRebate = moneyRebate;
}
public CashRebate(double moneyRebate) {
this.moneyRebate = moneyRebate;
}
public double acceptCash(double money) {
return money * moneyRebate;
}
}
return money * moneyRebate;
}
}
package org.leiwen.dp.action.stragety.basic;
/**
* 返利收费子类
*/
public class CashReturn extends CashSuper {
* 返利收费子类
*/
public class CashReturn extends CashSuper {
private double moneyCondition = 0.0;
private double moneyReturn = 0.0;
// 返利收费,初始化时必须要输入返利条件和返利值,比如满300返100,则moneyCondition=300,moneyReturn=100
public CashReturn(double moneyCondition, double moneyReturn) {
this.moneyCondition = moneyCondition;
this.moneyReturn = moneyReturn;
}
public CashReturn(double moneyCondition, double moneyReturn) {
this.moneyCondition = moneyCondition;
this.moneyReturn = moneyReturn;
}
public double acceptCash(double money) {
double result = money;
//若大于返利条件,则需要减去返利值
if (money >= moneyCondition) {
result = money - Math.floor(money / moneyCondition) * moneyReturn;
}
return result;
}
double result = money;
//若大于返利条件,则需要减去返利值
if (money >= moneyCondition) {
result = money - Math.floor(money / moneyCondition) * moneyReturn;
}
return result;
}
}
package org.leiwen.dp.action.stragety.basic;
//策略模式实现
public class CashContext {
private CashSuper cs;
//通过构造方法,传入具体的收费策略
public CashContext(CashSuper cs) {
this.cs = cs;
}
public CashContext(CashSuper cs) {
this.cs = cs;
}
public double getResult(double money) {
//根据收费策略的不同,获得计算结果
return cs.acceptCash(money);
}
}
//根据收费策略的不同,获得计算结果
return cs.acceptCash(money);
}
}
package org.leiwen.dp.action.stragety.basic;
/**
* @author 雷文 2012-2-17
* @since 1.0
*/
public class StragetyTest {
public static void main(String[] args) {
// 测试策略模式的实现
//CashSuper cs = CashFactory.createCashAccept(PayType.CASH_REBATE);
CashSuper cs = new CashRebate(0.8);
CashContext context = new CashContext(cs);
double money = context.getResult(200);
System.out.println("实收:" + money + "元");
// 测试策略模式的实现
//CashSuper cs = CashFactory.createCashAccept(PayType.CASH_REBATE);
CashSuper cs = new CashRebate(0.8);
CashContext context = new CashContext(cs);
double money = context.getResult(200);
System.out.println("实收:" + money + "元");
}
}
}
有任何赞美,批评,建议,意见,欢迎留言,欢迎拍砖。(*^__^*)
- 设计模式实战13--行为型--策略模式
- 设计模式 - 行为型模式 - 策略模式
- 设计模式->行为型模式->策略模式
- 设计模式--行为型--策略模式
- 设计模式14:策略模式【行为型】
- [设计模式-行为型]策略模式(Strategy)
- 设计模式-行为型之策略模式
- 行为型设计模式-策略模式
- java-行为型模式-策略设计模式
- 行为型的设计模式-策略模式
- 设计模式-行为-策略
- JAVA设计模式(13) —<行为型>策略模式(strategy)
- Java设计模式(13)行为型:策略模式
- 【JavaScript设计模式】行为型设计模式--策略模式
- 13-行为型-策略模式
- 设计模式--行为型-Strategy(策略)
- java设计模式之行为型模式-策略模式
- 设计模式之行为型模式---策略模式
- Struts2框架心法--第1招--Aware接口的使用技巧
- 事件响应机制与观察者模式
- 表达式引擎OGNL
- 设计模式实战序
- 设计模式实战6--结构型--装饰模式
- 设计模式实战13--行为型--策略模式
- 面向接口编程的一个小例子
- 棋盘问题 DFS+回溯
- 读书笔记(一)--卡耐基-沟通与人际关系
- 读书笔记(二)--你能行
- 嵌入式操作系统内核原理和开发(消息队列)
- 读书笔记(三)--世界上最伟大的推销员
- 读书笔记(四)--富爸爸,穷爸爸
- 读书笔记(五)--公司绝不会告诉你的50大秘密