`
zhb8015
  • 浏览: 397686 次
  • 性别: Icon_minigender_1
  • 来自: 北京
博客专栏
Group-logo
Spring Roo杂谈
浏览量:0
社区版块
存档分类
最新评论

strategy pattern

 
阅读更多


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 Pattern #### 概述 策略模式是一种行为设计模式,它使得算法可以在运行时被更改。这种模式允许一个类的行为或其算法在运行时根据需要进行改变,通过这种方式,我们可以轻松地扩展不同的算法...

    设计模式之策略模式(Strategy Pattern)

    在策略模式中,有三个主要角色:策略接口(Strategy Interface)、具体策略类(Concrete Strategy Classes)和上下文(Context)。策略接口定义了所有支持的算法的公共接口,这样上下文就可以通过这个接口来调用这些...

    设计模式之策略模式(Strategy Pattern)

    策略模式的主要组成部分包括上下文(Context)、策略接口(Strategy Interface)和具体策略类(Concrete Strategy Classes)。上下文维护一个对策略对象的引用,并使用这个引用来调用策略对象的算法。策略接口定义了...

    前端大厂最新面试题-Strategy Pattern.docx

    策略模式是一种设计模式,它使你能在运行时改变对象的行为,通过将算法封装在独立的策略类中,实现了策略的动态选择。这种模式的核心在于,它允许程序在不修改现有代码的情况下扩展功能,遵循“开闭原则”。...

    C#策略模式(Strategy Pattern)实例教程

    策略模式(Strategy Pattern)是一种行为设计模式,它使你能在运行时改变对象的行为。在C#中,策略模式常用于处理具有多种实现方式的情况,使得代码更加灵活,易于扩展。下面将详细讲解策略模式的概念、用途以及如何...

    The Factory Pattern(工厂模式)ppt

    工厂模式是一种常用的设计模式,它的主要目的是为了封装对象的创建过程,从而使得代码更加灵活,易于维护和扩展。在Head First设计模式中,工厂模式被用来解决对象创建时的“变化”问题,尤其是在需要根据条件动态...

    Strategy 模式 JAVA

    **策略模式(Strategy Pattern)**是面向对象设计模式中的一种行为模式,它允许在运行时改变对象的行为。在Java编程中,策略模式被广泛应用于处理算法的可互换性问题,使得程序能够根据不同的环境或者需求选择合适的...

    Java24种设计模式,Java24种设计模式,24种设计模式,学会了这24种设计模式,可以打遍天下无敌手,设计模式非常重要

    1、策略模式STRATEGY PATTERN 2、代理模式PROXY PATTERN 3、单例模式SINGLETON PATTERN 4、多例模式MULTITION PATTERN 5、工厂方法模式FACTORY METHOD PATTERN 6、抽象工厂模式ABSTRACT FACTORY PATTERN 7、门面模式...

    C#版 24种设计模式

    备忘录模式(Memento Pattern) 策略模式(Strategy Pattern) 抽象工厂模式(Abstract Factory Pattern) 代理模式(Proxy Pattern) 单例模式(Singleton Pattern) 迭代器模式(Iterator Pattern) 访问者模式(Visitor ...

    Software Architecture Design Pattern In Java

    5. **策略模式(Strategy Pattern)**: - 定义:定义了一系列算法,并将每一个算法封装起来,使它们可以相互替换。 - 应用场景:当应用程序需要根据不同情况执行不同的算法时,可以使用策略模式。 6. **适配器...

    design-pattern-java.pdf

    处理对象的多种状态及其相互转换——状态模式(五) 处理对象的多种状态及其相互转换——状态模式(六) 策略模式-Strategy Pattern 算法的封装与切换——策略模式(一) 算法的封装与切换——策略模式(二) 算法的...

    用Java实现23种设计模式

    策略模式(Strategy Pattern) 模板模式(Template Pattern) 访问者模式(Visitor Pattern) 4. J2EE 模式 MVC 模式(MVC Pattern) 业务代表模式(Business Delegate Pattern) 数据访问对象模式(Dao ...

    C#设计模式_设计模式_C#_

    创建型: 1. 单件模式(Singleton Pattern) 2. 抽象工厂(Abstract Factory) 3. 建造者模式(Builder) 4.... 策略模式(Strategy Pattern) 22. 访问者模式(Visitor Pattern) 23. 状态模式(State Pattern)

    factory strategy builder iterator

    2. **策略模式(Strategy Pattern)**: 策略模式定义了一系列的算法,并将每一个算法封装起来,使它们可以互相替换。策略模式让算法的变化独立于使用算法的客户。它允许在运行时动态选择执行的算法,增强了系统的...

    23种设计模式 (创建型,结构型,行为型)

    创建型: 1. 单件模式(Singleton Pattern) 2. 抽象工厂(Abstract Factory) 3.... 4.... 5.... 6. 适配器模式(Adapter ... 策略模式(Strategy Pattern) 22. 访问者模式(Visitor Pattern) 23. 状态模式(State Pattern)

    设计模式代码——c#

    C#设计模式(23种设计模式) 1. 单件模式(Singleton Pattern) 2. 抽象工厂(Abstract Factory) ...21. 策略模式(Strategy Pattern) 22. 访问者模式(Visitor Pattern) 23. 状态模式(State Pattern)

    设计模式PPT

    创建型模式用来处理对象的创建过程,主要包含以下5种设计模式:  工厂方法模式(Factory Method ... 策略模式(Strategy Pattern)  模板方法模式(Template Method Pattern)  访问者模式(Visitor Pattern)

    Refactoring-to-pattern

    - **简化型模式**:如策略模式(Strategy Pattern),用于封装算法,使它们可以互相替换,从而让算法的变化独立于使用算法的客户。 6. **实践建议** - **逐步改进**:书中提倡采用小步骤的方式进行重构,逐步...

    Python库 | django-strategy-field-1.1.1.tar.gz

    而`django-strategy-field`是Django生态中的一个实用库,它引入了策略模式(Strategy Pattern)的概念,为Django模型字段提供了灵活的行为管理。本文将深入探讨`django-strategy-field` 1.1.1版本的特性和使用方法。...

Global site tag (gtag.js) - Google Analytics