strategy pattern:
1 when: purpose
2 what: principle
3 how : examples
4 in all;
5 tutorial refer to url
STRATEGY—跟不同类型的MM约会,要用不同的策略,有的请电影比较好,有的则去吃小吃效果不错,有的去海边浪漫最合适,但目的都是为了得到MM的芳心,我的追MM锦囊中有好多Strategy哦。
策略模式:策略模式针对一组算法,将每一个算法封装到具有共同接口的独立的类中,从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。策略模式把行为和环境分开。环境类负责维持和查询行为类,各种算法在具体的策略类中提供。由于算法和环境独立开来,算法的增减,修改都不会影响到环境和客户端。
1 when: purpose
(1) 如果在一个系统里含有许多的类,它们之间的区别仅在于它们的行为,应该使用策略模式动态的选择其中的一种.
(2) 如果在一个系统里含有几种算法,需要动态的去选择其中的一种时,应该选择策略模式.
(3) 如果一个系统算法的复杂性和涉及的数据不想让客户端知道,应该选择策略模式.
(4) 如果一个对象有多种形为,应该使用策略模式来避免使用难以维护的多重条件语句来实现.
2 what: principle
(1) 策略模式就是把行为和环境(Context)分割开来,环境负责维持和查询行为类,各种算法则在具体策略类(ConcreteStrategy)中,由于算法和环境独立开来,算法的修改就不会影响到客户端.
(2) 策略模式的结构
这个模式涉及到三个角色:
A 环境角色(Context):持有一个Strategy类的引用.
B 抽象策略角色(Strategy):给出了所有具体角色类所需的接口,通常由一个接口或抽象类实现.
C 具体策略角色(ConcreteStrategy):包装了相关的算法和行为.
代码清单:
************************************************
Context:
package com.strategy;
public class Context {
private Strategy strategy;
/**
* strategy method
*/
public void contextInterface() {
strategy.strategyInterface();
}
}
Strategy:
package com.strategy;
public abstract class Strategy {
/**
* strategy method
*/
public abstract void strategyInterface();
}
ConcreteStrategy:
package com.strategy;
import java.io.Serializable;
public class ConcreteStrategy extends Strategy {
@Override
public void strategyInterface() {
}
}
************************************************
3 how: examples
实例一:
策略类(Strategy): Strategy.java(抽象类或接口)
具体策略类(ConcreteStrategy) : Add,Substract,Multiply,Divide
环境类(Context): Context上下文
代码清单**************************************************************
Strategy:::
package com.javapattern.strategy.calculate01;
public abstract class Strategy {
public abstract void operation(float a,float b);
}
Add::::
package com.javapattern.strategy.calculate;
public class Add extends Calculate {
public void operation(float a,float b) {
float add = a + b;
System.out.println("the result of a add b is " + add);
}
}
Substract::::
package com.javapattern.strategy.calculate;
public class Substract extends Calculate {
public void operation(float a,float b) {
float substract = a - b;
System.out.println("the result of a substract b is " + substract);
}
}
Multiply::::
package com.javapattern.strategy.calculate;
public class Multiply extends Calculate {
public void operation(float a,float b) {
float multiply = a * b;
System.out.println("the result of a * b is " + multiply);
}
}
Context::::
package com.javapattern.strategy.calculate01;
public class Context {
private Strategy strategy;
final static Strategy add = new Add();
final static Strategy substract = new Substract();
final static Strategy multiply = new Multiply();
final static Strategy divide = new Divide();
public void operation(float a,float b) {
strategy.operation(a, b);
}
}
测试类::::
package com.javapattern.strategy.calculate01;
public class Test {
public static void main(String[] args) {
float a = 100;
float b = 100;
Context.add.operation(a,b);
Context.substract.operation(a, b);
Context.multiply.operation(a, b);
Context.divide.operation(a, b);
}
}
实例二:
图书折扣的算法:
图书销售中的折扣计算问题,假设有三种折扣三种算法:
算法一: 没有折扣,返回0为折扣值.
算法二: 一元的折扣.
算法三: 百分比折扣,比如一本书的价格为20,折扣百分比为7%,则折扣价为20*7%=1.4
角色分配:
策略类(Strategy): DiscountStrategy.java
具体策略类(ConcreteStrategy) : 算法一二三 NoDiscountStrategy.java,FlatRateStrategy.java,PrecentageStrategy.java
环境类(Context): DiscountContext.java
结构图:
代码清单:****************************************
context::::::::
package com.javapattern.strategy.booksales01;
public class ContextStrategy {
private DiscountStrategy strategy = null;
public ContextStrategy(DiscountStrategy strategy) {
this.strategy = strategy;
}
public double calculateStrategy() {
return this.strategy.calculateStrategy();
}
}
strategy::::::
package com.javapattern.strategy.booksales01;
/**
* strategy class
* @author Administrator
*
*/
public abstract class DiscountStrategy {
public double price = 0;
public int copies = 0;
public DiscountStrategy(double price,int copies) {
this.price = price;
this.copies = copies;
}
public abstract double calculateStrategy();
}
ConcreteStrategy::::::
package com.javapattern.strategy.booksales01;
/**
* concreteStrategy class
* @author Administrator
*
*/
public class NoDiscountStrategy extends DiscountStrategy {
public NoDiscountStrategy(double price,int copies) {
super(price,copies);
}
public double calculateStrategy() {
return 0;
}
}
package com.javapattern.strategy.booksales01;
/**
* concreteStrategy
* @author Administrator
*
*/
public class FlatDiscountStrategy extends DiscountStrategy {
private double amount = 10;
public FlatDiscountStrategy(double price,int copies) {
super(price,copies);
}
public double calculateStrategy() {
return copies * amount;
}
public void setAmount(double amount) {
this.amount = amount;
}
public double getAmount() {
return amount;
}
}
package com.javapattern.strategy.booksales01;
/**
* concreteStrategys class
* @author Administrator
*
*/
public class PrecentageDiscountStrategy extends DiscountStrategy {
private double precentage = 0.2;
public PrecentageDiscountStrategy(double price,int copies) {
super(price,copies);
}
public double calculateStrategy() {
return price * copies * precentage;
}
public void setPrecentage(double precentage) {
this.precentage = precentage;
}
public double getPrecentage() {
return precentage;
}
}
测试类::::
package com.javapattern.strategy.booksales01;
public class Test {
public static void main(String[] args) {
double price = 100;
int copies = 2000;
double discountAmt = 0;
// DiscountStrategy noDiscountStrategy = new NoDiscountStrategy(price,copies);
// DiscountStrategy flatDiscountStrategy = new FlatDiscountStrategy(price, copies);
DiscountStrategy flatDiscountStrategy = new PrecentageDiscountStrategy(price, copies);
ContextStrategy ctx = new ContextStrategy(flatDiscountStrategy);
discountAmt = ctx.calculateStrategy();
System.out.println("discount amount is " + discountAmt);
}
}
*************************************************
**********************************************************************
5 tutorial refer to url
<<java and pattern>>
晨曦视频
GOF
分享到:
相关推荐
### 策略模式 Strategy Pattern #### 概述 策略模式是一种行为设计模式,它使得算法可以在运行时被更改。这种模式允许一个类的行为或其算法在运行时根据需要进行改变,通过这种方式,我们可以轻松地扩展不同的算法...
在策略模式中,有三个主要角色:策略接口(Strategy Interface)、具体策略类(Concrete Strategy Classes)和上下文(Context)。策略接口定义了所有支持的算法的公共接口,这样上下文就可以通过这个接口来调用这些...
策略模式的主要组成部分包括上下文(Context)、策略接口(Strategy Interface)和具体策略类(Concrete Strategy Classes)。上下文维护一个对策略对象的引用,并使用这个引用来调用策略对象的算法。策略接口定义了...
策略模式是一种设计模式,它使你能在运行时改变对象的行为,通过将算法封装在独立的策略类中,实现了策略的动态选择。这种模式的核心在于,它允许程序在不修改现有代码的情况下扩展功能,遵循“开闭原则”。...
策略模式(Strategy Pattern)是一种行为设计模式,它使你能在运行时改变对象的行为。在C#中,策略模式常用于处理具有多种实现方式的情况,使得代码更加灵活,易于扩展。下面将详细讲解策略模式的概念、用途以及如何...
工厂模式是一种常用的设计模式,它的主要目的是为了封装对象的创建过程,从而使得代码更加灵活,易于维护和扩展。在Head First设计模式中,工厂模式被用来解决对象创建时的“变化”问题,尤其是在需要根据条件动态...
**策略模式(Strategy Pattern)**是面向对象设计模式中的一种行为模式,它允许在运行时改变对象的行为。在Java编程中,策略模式被广泛应用于处理算法的可互换性问题,使得程序能够根据不同的环境或者需求选择合适的...
1、策略模式STRATEGY PATTERN 2、代理模式PROXY PATTERN 3、单例模式SINGLETON PATTERN 4、多例模式MULTITION PATTERN 5、工厂方法模式FACTORY METHOD PATTERN 6、抽象工厂模式ABSTRACT FACTORY PATTERN 7、门面模式...
备忘录模式(Memento Pattern) 策略模式(Strategy Pattern) 抽象工厂模式(Abstract Factory Pattern) 代理模式(Proxy Pattern) 单例模式(Singleton Pattern) 迭代器模式(Iterator Pattern) 访问者模式(Visitor ...
5. **策略模式(Strategy Pattern)**: - 定义:定义了一系列算法,并将每一个算法封装起来,使它们可以相互替换。 - 应用场景:当应用程序需要根据不同情况执行不同的算法时,可以使用策略模式。 6. **适配器...
处理对象的多种状态及其相互转换——状态模式(五) 处理对象的多种状态及其相互转换——状态模式(六) 策略模式-Strategy Pattern 算法的封装与切换——策略模式(一) 算法的封装与切换——策略模式(二) 算法的...
策略模式(Strategy Pattern) 模板模式(Template Pattern) 访问者模式(Visitor Pattern) 4. J2EE 模式 MVC 模式(MVC Pattern) 业务代表模式(Business Delegate Pattern) 数据访问对象模式(Dao ...
创建型: 1. 单件模式(Singleton Pattern) 2. 抽象工厂(Abstract Factory) 3. 建造者模式(Builder) 4.... 策略模式(Strategy Pattern) 22. 访问者模式(Visitor Pattern) 23. 状态模式(State Pattern)
2. **策略模式(Strategy Pattern)**: 策略模式定义了一系列的算法,并将每一个算法封装起来,使它们可以互相替换。策略模式让算法的变化独立于使用算法的客户。它允许在运行时动态选择执行的算法,增强了系统的...
创建型: 1. 单件模式(Singleton Pattern) 2. 抽象工厂(Abstract Factory) 3.... 4.... 5.... 6. 适配器模式(Adapter ... 策略模式(Strategy Pattern) 22. 访问者模式(Visitor Pattern) 23. 状态模式(State Pattern)
C#设计模式(23种设计模式) 1. 单件模式(Singleton Pattern) 2. 抽象工厂(Abstract Factory) ...21. 策略模式(Strategy Pattern) 22. 访问者模式(Visitor Pattern) 23. 状态模式(State Pattern)
创建型模式用来处理对象的创建过程,主要包含以下5种设计模式: 工厂方法模式(Factory Method ... 策略模式(Strategy Pattern) 模板方法模式(Template Method Pattern) 访问者模式(Visitor Pattern)
- **简化型模式**:如策略模式(Strategy Pattern),用于封装算法,使它们可以互相替换,从而让算法的变化独立于使用算法的客户。 6. **实践建议** - **逐步改进**:书中提倡采用小步骤的方式进行重构,逐步...
而`django-strategy-field`是Django生态中的一个实用库,它引入了策略模式(Strategy Pattern)的概念,为Django模型字段提供了灵活的行为管理。本文将深入探讨`django-strategy-field` 1.1.1版本的特性和使用方法。...