Java设计模式6:策略模式

策略模式

策略模式的用意是针对一组算法,将每一个算法封装到具有共同接口的独立类中,从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。

策略模式的结构

策略模式是对算法的包装,是把使用算法的责任和算法本身分开。策略模式通常是把一系列的算法包装到一系列的策略类里面,作为一个抽象策略类的子类。

策略模式涉及到三个角色:

1、环境角色

持有一个策略Strategy的引用

2、抽象策略角色

这是一个抽象角色,通常由一个接口或抽象类实现,此角色给出所有具体策略类所需的接口

3、具体策略角色

包装了相关算法或行为

策略模式示例

有一个抽象的策略接口:

public interface Strategy
{
    public void useStrategy();
}

实现两种具体的策略:

public class StrategyA implements Strategy
{
    public void useStrategy()
    {
        System.out.println("StrategyA.useStrategy()");
    }
}
public class StrategyB implements Strategy
{
    public void useStrategy()
    {
        System.out.println("StrategyB.useStrategy()");
    }
}

某个类持有策略的引用:

public class Context
{
    private Strategy strategy;

    public Context(Strategy strategy)
    {
        this.strategy = strategy;
    }

    public void strategyMethod()
    {
        strategy.useStrategy();
    }
}

调用这个类的地方可以自行决定使用哪种策略:

public class TestMain
{
    public static void main(String[] args)
    {
        Strategy strategyA = new StrategyA();
        Strategy strategyB = new StrategyB();

        Context context = new Context(strategyA);
        context.strategyMethod();
        context = new Context(strategyB);
        context.strategyMethod();
    }
}

策略模式的使用场景

举一个实际例子吧。假如有一个购物系统,在用户付款的时候,会产生很多场景,根据用户的不同情况算出不同用户要付款的金额,这时候最直观的一种做法是:

在付款的里面写N多的if...else if...else,判断用户的场景,根据场景计算用户付款金额。

这种设计明显违反了开闭原则。开闭原则的"闭",指的是对修改关闭,但是这里假如算法又多了几种,那么必须再次修改这个付款的类。

这时候就可以使用策略模式。在付款的类里面持有一个付款接口的引用,每次根据不同场景传入一个具体的策略就好了。比如A类中要使用S0算法,就传入一个S0策略;B类中要使用S1算法,就传入一个S1算法。不需要把判断都放在付款的类中,代码的可读性、可维护性也更高了。付款这个类甚至可以直接生成一个.class文件放在一个jar包里面供调用。

策略模式在Java中的应用及解读

策略模式在Java中的应用,这个太明显了,因为Comparator、Comparable这两个接口简直就是为策略模式而生的。Comparable和Comparator的区别一文中,详细讲了Comparator的使用。比方说Collections里面有一个sort方法,因为集合里面的元素有可能是复合对象,复合对象并不像基本数据类型,可以根据大小排序,复合怎么排序呢?所以,Java要求如果定义的复合对象要有排序的功能,就自行实现Comparable接口:

1 public static <T extends Comparable<? super T>> void sort(List<T> list) {
2     Object[] a = list.toArray();
3     Arrays.sort(a);
4     ListIterator<T> i = list.listIterator();
5     for (int j=0; j<a.length; j++) {
6         i.next();
7         i.set((T)a[j]);
8     }
9     }

第3行的sort方法跟一下:

1 public static void sort(Object[] a) {
2         Object[] aux = (Object[])a.clone();
3         mergeSort(aux, a, 0, a.length, 0);
4     }

第3行的mergeSort方法跟一下就明显了:

 1 private static void mergeSort(Object[] src,
 2                   Object[] dest,
 3                   int low,
 4                   int high,
 5                   int off) {
 6     int length = high - low;
 7
 8     // Insertion sort on smallest arrays
 9         if (length < INSERTIONSORT_THRESHOLD) {
10             for (int i=low; i<high; i++)
11                 for (int j=i; j>low &&
12              ((Comparable) dest[j-1]).compareTo(dest[j])>0; j--)
13                     swap(dest, j, j-1);
14             return;
15         }
16
17         // Recursively sort halves of dest into src
18         int destLow  = low;
19         int destHigh = high;
20         low  += off;
21         high += off;
22         int mid = (low + high) >>> 1;
23         mergeSort(dest, src, low, mid, -off);
24         mergeSort(dest, src, mid, high, -off);
25
26         // If list is already sorted, just copy from src to dest.  This is an
27         // optimization that results in faster sorts for nearly ordered lists.
28         if (((Comparable)src[mid-1]).compareTo(src[mid]) <= 0) {
29             System.arraycopy(src, low, dest, destLow, length);
30             return;
31         }
32
33         // Merge sorted halves (now in src) into dest
34         for(int i = destLow, p = low, q = mid; i < destHigh; i++) {
35             if (q >= high || p < mid && ((Comparable)src[p]).compareTo(src[q])<=0)
36                 dest[i] = src[p++];
37             else
38                 dest[i] = src[q++];
39         }
40     }

看第12行,每次排序根据compareTo的结果决定是否swap(交换)。

Comparator接口应用也有很多,Collections里面就有一个sort的重载方法,可以传入一个Comparator的子类:

public static <T> void sort(List<T> list, Comparator<? super T> c) {
    Object[] a = list.toArray();
    Arrays.sort(a, (Comparator)c);
    ListIterator i = list.listIterator();
    for (int j=0; j<a.length; j++) {
        i.next();
        i.set(a[j]);
    }
    }

Collections将根据具体Comparator的策略来对集合进行排序。

认识策略模式

应当明白,策略模式的重心不是如何实现算法(就如同工厂模式的重心不是工厂中如何产生具体子类一样),而是如何组织、调用这些算法,从而让程序结构更灵活,具有更好的维护性和扩展性。

策略模式有一个很大的特点就是各策略算法的平等性。对于一系列具体的策略算法,大家的地位是完全一样的,正因为这个平等性,各个算法之间才可以相互替换。

运行期间,每一个时刻只能使用一个具体的策略实现对象,虽然可以动态地在不同的策略中实现切换。

策略模式的优缺点

优点

1、避免了多重条件if...else if...else语句,多重条件语句并不容易维护

2、策略模式提供了管理相关算法簇的办法,恰当使用继承可以把公共代码移到弗雷连,从而避免了代码重复。

缺点

1、客户端必须知道所有的策略类,并自行决定使用 哪一个策略,这意味着客户端必须理解这些算法的区别,以便选择恰当的算法

2、如果备选策略很多,对象的数据会很多

时间: 2024-10-13 07:32:31

Java设计模式6:策略模式的相关文章

Java 设计模式之 策略模式

思维导图: 我们先来看 STRATEGY 设计模式的通俗解释: 跟不同类型的MM约会,要用不同的策略,有的请电影比较好,有的则去吃小吃效果不错,有的去海边浪漫最合适,但目的都是为了得到 MM 的芳心,我的追 MM 锦囊中有好多 Strategy 哦.策略模式: 策略模式针对一组算法,将每一个算法封装到具有共同接口的独立的类中,从而使得它们可以相互替换. 策略模式使得算法可以在不影响到客户端的情况下发生变化.策略模式把行为和环境分开.环境类负责维持和查询行为类,各种算法在具体的策略类中提供.由于算

Java设计模式1——策略模式(Strategy Pattern)

最近觅得一本好书<您的设计模式>,读完两章后就能断言,一定是一头极品屌丝写的,而且是专写给开发屌丝男的智慧枕边书,小女子就委屈一下,勉强看看,人笨,谁让他写得这么通俗易懂呢!为了加深理解,用自己的方式记录下来. 上第一章的策略模式之前讲个故事,解释一下类设计的背景:刘备要去江东娶老婆,临走时诸葛亮给伴郎赵云三个锦囊妙计,嘱咐按天机拆开解决棘手问题.这才有了后来的周瑜赔了夫人又折兵.三个妙计放在锦囊中,赵云从锦囊中取妙计获胜.先看类图: 1.三个妙计是具体的实现类,我们设计一个接口,再写三个实现

折腾Java设计模式之策略模式

博客原文地址 简介 在策略模式(Strategy Pattern)中,一个类的行为或其算法可以在运行时更改.这种类型的设计模式属于行为型模式.简单理解就是一组算法,可以互换,再简单点策略就是封装算法. 意图 定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换. 主要解决 在有多种算法相似的情况下,使用 if...else 所带来的复杂和难以维护. 何时使用 一个系统有许多许多类,而区分它们的只是他们直接的行为. 如何解决 将这些算法封装成一个一个的类,任意地替换. 主要角色 上下文C

java设计模式之——策略模式

1.策略模式有什么好处? 策略模式的好处在于你可以动态的改变对象的行为. 2.设计原则 设计原则是把一个类中经常改变或者将来可能改变的部分提取出来,作为一个接口(c++中可以用虚类),然后在类中包含这个对象的实例,这样类的实例在运行时就可以随意调用实现了这个接口的类的行为.下面是一个例子. 策略模式属于对象行为型模式,主要针对一组算法,将每一个算法封装到具有共同接口的独立的类中,从而使得它们可以相互替换.策略模式使得算法可以在不影响 到客户端的情况下发生变化.通常,策略模式适用于当一个应用程序需

java设计模式7.策略模式、模板方法模式、观察者模式

策略模式 策略模式的用意,将每一个算法封装到具有共同接口的独立的类中,从而使得它们可以相互替换.策略模式使得算法可以在不影响到客户端的情况下发生变化. 环境角色:持有一个抽象策略角色的引用. 抽象策略角色:给出所有的具体策略类所要实现的接口. 具体策略角色:包装相关的算法或行为. 模板方法模式 模板方法的用意,使用一个抽象类,将部分逻辑以具体方法以及具体构造子的形式实现,然后声明一些抽象方法来迫使子类实现剩余的逻辑.不同的子类可以用不同的方式来实现这些抽象方法. 抽象模板角色:1. 定义一个或多

JAVA设计模式之策略模式 - Strategy

在策略模式(Strategy Pattern)中,一个类的行为或其算法可以在运行时更改.这种类型的设计模式属于行为型模式. 在策略模式中,我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的 context 对象.策略对象改变 context 对象的执行算法. 介绍 什么是策略模式(Strategy Pattern) 在软件开发过程中常常遇到这样的情况, 实现某一个功能有很多种算法或实现策略, 我们可以根据环境或者条件的不同选择不同的算法或者策略来完成该功能. 如果将这些算法或者策略抽象

java设计模式之策略模式

策略模式 模拟鸭子游戏SimUDuck 设计原则: 找出应用中需要变化之处,把它们独立出来,不需要和那些变化的代码混在一起 设计原则: 针对接口编程,而不是针对实现编程 设计原则: 多用组合,少用继承 策略模式定义: 定义了算法族,分别封装起来,让他们之间可以相互替换,此模式让算法的变化独立于使用算法的客户 1 public class MiniDuckSimulator 2 { 3 public static void main(String[] args) 4 { 5 //绿头鸭 6 Duc

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

前言: 最近一直在学习基于okHttp网络请求,学习的过程中就想起了之前项目中有这么一个需求不同的接口要采用不同的加密方式,比如登录之前要采用RSA加密,登录之后要采用AES加密,当时是采用靠传递一个参数过去来对参数进行不同的加密算法,这样会让代码难以维护而且难以扩展,那该如何解决呢?今天来学习一下策略模式Strategy!用它来解决这个问题. 策略模式:        策略模式属于对象的行为模式.其用意是针对一组算法,将每一个算法封装到具有共同接口的独立的类中,从而使得它们可以相互替换.策略模

java设计模式之策略模式总结

策略模式的定义:(定义截自http://www.cnblogs.com/whgk/p/6087064.html) 1.策略模式定义了算法族,分别封装起来,让他们之间可以互相替换,此模式让算法的变化独立于使用算法的客户 换句话讲,也就是将那些使用的方法分别封装成独立的类,然后将这一类使用接口统一管理起来,让需要使用这些方法的用户能够随时调用它们.上面例子中的战斗行为就相当于定义中的算法一词.只是换了个说法而已. 缺点: 1.客户端必须知道所有的策略类,并自行决定使用哪一个策略类.这就意味着客户端必

设计模式:策略模式(Strategy)

定义一系列的算法,把它们一个个封装起来,并且使它们可相互替换.本模式使得算法可独立于使用它的客户而变化. 策略模式的角色: 1. 抽象策略角色(Strategy):策略类,通常由一个接口或者抽象类实现 2. 具体策略角色(ConcreteStrategy):包装了相关的算法和行为 3. 环境角色(Context):持有一个策略类的引用,最终给客户端调用 这里引用参考资料3中的例子来详细说明一下策略模式. "赔了夫人又折兵"--这个是<三国演义>里的著名桥段,主要是说刘备要去