策略模式与简单工厂模式的结合使用

  Java设计模式中的策略模式(Strategy Patten)定义了一组算法,将每个算法都封装起来,并且可使它们之间可以相互替换,在客户端调用它们时可以互不影响。

策略模式主要由三个角色组成

1、抽象策略角色:通常是一个接口或抽象类实现,我们的具体策略类就是继承或实现这个抽象角色。

2、具体策略角色:我们在这些类中写策略和算法,继承或实现抽象策略角色。

3、环境角色:环境角色中拥有一个抽象策略角色的引用,供客户端调用,该角色把客户端跟策略类的实现分离。

从上面的三个策略模式的角色中,我们就大概可以知道策略模式的编写步骤,这里以实现简单的四则运算为例。

1、定义抽象策略角色,也就是定义一个公共的抽象类(也可以是接口)

 1 package strategy;
 2 /**
 3  *
 4  * @author CIACs
 5  *定义抽象策略角色
 6  */
 7 public abstract class Strategy {
 8     //定义抽象策略的方法
 9     public abstract int strategy(int a,int b);
10
11 }

2、编写策略类,该类实现上面定义的抽象类

 1 package strategy;
 2 /**
 3  *
 4  * @author CIACs
 5  * AddStrategy
 6  */
 7 public class AddStrategy extends Strategy {
 8     //定义实现加法的策略方法
 9     public int strategy(int a, int b)
10     {
11         return a+b;
12     }
13
14 }
 1 package strategy;
 2 /**
 3  *
 4  * @author CIACs
 5  *    SubStrategy
 6  */
 7 public class SubStrategy extends Strategy {
 8     //定义减法的策略方法
 9     public int strategy(int a, int b)
10     {
11         return a-b;
12     }
13
14 }
 1 package strategy;
 2 /**
 3  *
 4  * @author CIACs
 5  *    MultiplyStrategy
 6  */
 7 public class MultiplyStrategy extends Strategy {
 8     //定义乘法的策略方法
 9     public int strategy(int a,int b)
10     {
11         return a*b;
12     }
13 }
 1 package strategy;
 2 /**
 3  *
 4  * @author CIACs
 5  *    DivStrategy
 6  */
 7 public class DivStrategy extends Strategy {
 8     //定义除法的策略方法,这里为了简单就不考虑除数为零的情况了
 9     public int strategy(int a,int b)
10     {
11         return a/b;
12     }
13 }

3、编写环境角色,其中持有一个抽象策略类的引用

 1 package strategy;
 2 /**
 3  *
 4  * @author CIACs
 5  *    Context
 6  */
 7 public class Context {
 8     //持有抽象策略角色的引用,用于客户端调用
 9     private Strategy strategy;
10     //获得策略类
11     public Strategy getStrategy() {
12         return strategy;
13     }
14     //设置所需策略
15     public void setStrategy(Strategy strategy) {
16         this.strategy = strategy;
17
18     }
19     //根据设置的策略类返回对应的结果
20     public int getResult(int a,int b)
21     {
22         return strategy.strategy(a, b);
23     }
24
25 }

4、编写客户端

 1 package strategy;
 2 /**
 3  *
 4  * @author CIACs
 5  *    Client
 6  */
 7 public class Client {
 8     public static void main(String[] args) {
 9
10         Context context = new Context();
11
12         int result;
13
14         context.setStrategy(new SubStrategy());
15
16         result = context.getResult(9, 3);
17
18         System.out.println("sub: "+result);
19
20         context.setStrategy(new AddStrategy());
21
22         result =context.getResult(9, 3);
23
24         System.out.println("add: "+result);
25
26         context.setStrategy(new DivStrategy());
27
28         result = context.getResult(9, 3);
29
30         System.out.println("div: "+result);
31
32         context.setStrategy(new MultiplyStrategy());
33
34         result = context.getResult(9, 3);
35
36         System.out.println("mul: "+result);
37     }
38 }

输出结果:

上面只是用到策略模式,下面加上简单工厂模式

工厂类

 1 package strategy;
 2 /**
 3  *
 4  * @author CIACs
 5  *    Factory
 6  */
 7 public class Factory {
 8     public Strategy createStrategy(String str)
 9     {
10         if("AddStrategy".equalsIgnoreCase(str))
11         {
12             return new AddStrategy();
13         }
14         else
15             if("SubStrategy".equalsIgnoreCase(str))
16             {
17                 return new SubStrategy();
18             }
19             else
20                 if("DivStrategy".equalsIgnoreCase(str))
21                 {
22                     return new DivStrategy();
23                 }
24                 else
25                     if("MultiplyStrategy".equalsIgnoreCase(str))
26                     {
27                         return new MultiplyStrategy();
28                     }
29                     else
30                         return null;
31     }
32
33 }

客户端类

 1 package strategy;
 2 /**
 3  *
 4  * @author CIACs
 5  *    Client
 6  */
 7 public class Client {
 8     public static void main(String[] args) {
 9
10         Context context = new Context();
11         int result;
12         Strategy strategy;
13         Factory fac = new Factory();
14         strategy = fac.createStrategy("AddStrategy");
15         context.setStrategy(strategy);
16             result = context.getResult(9, 3);
17         System.out.println(result);
18     }
19 }

输出结果:

当然这里的工厂类中的if-else的使用是不太好的,简单工厂模式把生成策略类与客户端分离。

总结:

  策略模式使开发人员能够开发出很多可替换的组件,而组件间是弱连接的,体现了代码的可重用行,弱连接也为以后开发新的组件打下了基础,具有较强的可扩展性,易于维护。策略模式是对算法的封装它把算法的责任和算法本身分割开委派给别的对象管理客户端决定应该使用什么策略,因此客户端需要理解所有具体策略类之间的区别,这也增加了客户端的使用难度。

时间: 2024-10-02 19:13:31

策略模式与简单工厂模式的结合使用的相关文章

设计模式笔记——策略模式VS简单工厂模式

策略模式VS简单工厂模式   策略模式(Strategy)它定义了算法家族,分别封装起来,让他们之间可以相互替换,此模式让算法的变化,不会影响到使用算法的客户. 1.组成 -抽象策略角色: 策略类,通常由一个接口或者抽象类实现. -具体策略角色:包装了相关的算法和行为. -环境角色:持有一个策略类的引用,最终给客户端调用. 2.应用场景 - 多个类只区别在表现行为不同,可以使用Strategy模式,在运行时动态选择具体要执行的行为. -需要在不同情况下使用不同的策略(算法),或者策略还可能在未来

设计模式之策略模式&简单工厂模式

学习设计模式已经有非常长一段时间了,事实上先前已经敲过一遍了.可是老认为没有学到什么,认识也不够深刻.如今趁着重构机房,再又一次来过,也不晚. 事实上在敲了机房之后,看看模式,事实上,曾经非常难理解.非常难看懂的代码一眼就能够看懂了,趁着有点感觉了.早点收获吧. 简单工厂模式: 简单地说简单工厂模式:非常easy变化的地方,就能够用到简单工厂模式. 实例: 举个样例:我们在逛商场时.正好商场促销,各种优惠活动:有满300返100 ,有打8折的.抽奖等等吧. 促销来讲,各种优惠活动事实上就是变化.

策略模式与简单工厂模式

1,简单工厂模式 a) 有一个抽象的接口用来表示工厂需要生产的产品共性:然后各个具体的产品类实现该抽象接口. b) 工厂只需要持有产品的抽象接口,工厂接收一个 TYPE 参数来决定生产何种产品. c) 对于客户而言,当他需要某种类型的产品时,只需要获得工厂对象,然后将产品的 TYPE参数传递给工厂,由工厂创建他所需要的产品. 2,策略模式 策略,本质上是一种算法.当客户需要处理某件事情时,由于所处的环境不同,他可以采取不同的方式(策略)去处理.因此,客户关注的是如何方便得获取所需的策略. a)

java笔记--策略模式和简单工厂模式

策略模式: --如果朋友您想转载本文章请注明转载地址"http://www.cnblogs.com/XHJT/p/3884781.html "谢谢-- 为什么使用:策略模式主要用于有很多不同的方式来解决同一个问题的情景.如:文件的保存:可保存成txt,也可保存成xml.另外压缩文件.商场的促销策略等是类似的 如何使用:需要定义一个接口或者抽象类来表示各种策略的抽象,由于在选择适当的策略上有些不方便,需要不断地判断需要的类型,因此需要用简单工厂方法来实现判断过程 例子: 用策略模式实现图

java设计模式 -------- 创建模式 之 简单工厂模式

本文是自己学习所做笔记,欢迎转载,但请注明出处:http://blog.csdn.net/jesson20121020 工厂模式是最常用的模式,因为工厂模式就相当于创建实例对象的new,我们经常要根据类Class生成实例对象,如A a = new A(),工厂模式也是用来创建用来创建实例对象的,所以以后new时要多个心眼,是否可以考虑使用工厂模式. 简单工厂模式又可以分成三种模式: 1) 普通简单工厂模式 2) 多方法简单工厂模式 3) 多静态方法简单工厂模式 普通简单工厂模式: 举例:(简单的

大话设计模式第八章---工厂模式及简单工厂模式比较

(简单工厂模式) (工厂模式) 简单工厂模式: 最大优点在于工厂类中包含了必要的逻辑判断,根据客户端的选择条件动态实例化相关的类,对于客户端来说,去除了与具体产品的依赖.不过,违背了开放-封闭原则. 工厂模式: 定义一个用于创建对象的接口,让子类决定实例化哪一个类.工厂方法使一个类的实例化延迟到其子类. 工厂模式实现时,客户端需要决定实例化哪一个工厂来实现运算类,选择判断的问题还是存在的,也就是说,工厂方法把简单工厂的内部逻辑判断转移到了客户端代码来进行.你想要加功能,在简单工厂模式中是改工厂类

设计模式_创建型模式_简单工厂模式

转载自:http://blog.csdn.net/lovelion  作者:刘伟 简单工厂模式并不属于GoF 23个经典设计模式,但通常将它作为学习其他工厂模式的基础,它的设计思想很简单,其基本流程如下:        首先将需要创建的各种不同对象(例如各种不同的Chart对象)的相关代码封装到不同的类中,这些类称为具体产品类, 而将它们公共的代码进行抽象和提取后封装在一个抽象产品类中,每一个具体产品类都是抽象产品类的子类: 然后提供一个工厂类用于创建各种产品,在工厂类中提供一个创建产品的工厂方

策略模式+单例模式+简单工厂模式:推送服务

一.功能: 实现  获取数据  —>根据用户订阅清单进行推送 —> 这里的推送方式:QQ.Email.App.插件等等 用户可多选推送方式. 二.实现 1.推送方式—枚举(位运算): [Flags] public enum PushType { QQ = 0, Email = 2 } 2.策略模式:抽象推送策略 public interface IPush { bool Push(object data); } 3.QQ推送+Email推送 QQ推送:单例模式—静态创建QQ推送服务,线程安全.

策略模式结合简单工厂模式

概述 策略模式是一种定义一系列算法的方法,从概念上来看,所有这些算法完成的都是相同的工作,只是实现不同,它可以以相同的方式调用所有的算法,减少各种算法类与使用算法类之间的耦合. 场景 超市收营员收钱,有打几折.满多少返现.正常收费等活动来最终算出客户应该付多少现金. 1.现金收款超类 package com.gzy.designpattern.strategyandfactory; /* * @program: mybatis-plus * @description: 现金收款超类 * @aut