java策略设计模式

最新推荐文章于 2021-02-16 15:56:06 发布
最新推荐文章于 2021-02-16 15:56:06 发布
阅读量651 收藏
点赞数
分类专栏： java 文章标签： 策略设计模式

定义： 策略模式是一种定义一系列算法的方法，从概念上来看，所有这些算法完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少各种算法类与使用算法类之间的耦合关系。

    策略模式主要用一个类（context环境类）来承接上下文，配置维护一个对所有算法父类对象的引用。

    策略模式遵循的结构图如下：

     
Context(应用场景): 
     1 需要使用ConcreteStrategy提供的算法。 
    2 内部维护一个Strategy的实例。 
    3 负责动态设置运行时Strategy具体的实现算法。 
    4 负责跟Strategy之间的交互和数据传递。 
Strategy(抽象策略类)： 
    1 定义了一个公共接口，各种不同的算法以不同的方式实现这个接口，Context使用这个接口调用不同的算法，一般使用接口或抽象类实现。 
ConcreteStrategy(具体策略类)： 
    1 实现了Strategy定义的接口，提供具体的算法实现。

下面列举一个开发过程中的实例进行讲解：
    模块功能：UI界面通过不同的操作详细向服务端发送请求，并且处理相应结果。
    1.请求apk信息，发送给UI。
    2.请求apk、图片下载。
    3.请求应用版本，通知UI是否可以更新。
    4.请求查询信息。

对于上面同一个模块功能，下面将列举四个例子来进行比较：
    （1）常规的操作方法。
    （2）策略模式实现
    （3）策略模式+简单工厂
    （4）策略模式+反射机制

1）一般代码架构情形：
    枚举类型：   RequestChoise------请求类型
    UI客户端：   UIClient-------------请求发起、调用者
    枚举类型RequestChoise.java 

1 package com.zlc.all;
2  
3 public enum RequestChoise {
4         REQUEST_APK_MSG,//请求apk详情
5         REQEUST_APK_IMG_DOWNLOAD,//请求下载
6         REQUEST_VERSION,//请求版本号
7         REQUEST_SEARCH_MSG//请求查询信息
8 }
           UIClient.java  
01 package com.zlc.nomal;
02  
03 import com.zlc.all.RequestChoise;
04  
05 public class UIClient {
06     String  msg = "";
07     public void questMsg(RequestChoise choise,String url){
08         switch (choise) {
09         case REQUEST_APK_MSG:
10             System.out.println("1:请求apk信息");
11             System.out.println("2:把数据通知给UI");
12             System.out.println("3:…………");
13             break;
14         case REQEUST_APK_IMG_DOWNLOAD:
15             System.out.println("1:请求apk/图片下载");
16             System.out.println("2:把数据保存到文件");
17             System.out.println("3:通知UI已经下载成功或失败");
18             System.out.println("4:…………");
19             break;
20         case REQUEST_VERSION:
21             System.out.println("1:请求该应用版本信息");
22             System.out.println("2:与本身应用的版本进行比较");
23             System.out.println("3:通知UI显示是否更新对话框");
24             System.out.println("4:…………………………");
25             break;
26         case REQUEST_SEARCH_MSG:
27             System.err.println("1:请求搜索框输入的信息");
28             System.out.println("2:获取到的信息进行分页提示UI显示");
29             System.out.println("3:……………………");
30             break;
31         default:
32             break;
33         }
34     }
35 }
这样写缺点：  1.客户端代码量多、繁杂。  
                   2.客户端耦合性高，涉及到多个类。  
                   3.客户端重复代码较多如：多次调用


2）使用策略模式：
    刚我们提到策略模式涉及到三个角色：
    环境（Context）角色：持有一个Strategy类的引用。 
    抽象策略（Strategy）角色：这是一个抽象角色，通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。 
    具体策略（ConcreteStrategy）角色：包装了相关的算法或行为。     
    
（1）抽象算法类：Request-------------提供公共接口
（2）具体算法类：RequestAPKMsg----请求apk详细信息
       具体算法类：RequestDownload--请求下载资源
       具体算法类：RequestSearchMsg-请求搜索结果
       具体算法类：RequestVersion-----请求版本信息
（3）环境角色类：RequestContext------持有一个Request类的引用，提供具体算法调用接口
       枚举类型：   RequestChoise------请求类型
       UI客户端：   UIClient-------------请求发起、调用者


    Request.java    

1 package com.zlc.all;
2 /**
3  * 抽象算法类：Request
4  * 提供公共的请求接口
5  * **/
6 public interface Request {
7      
8     public void requestFromeServer(String url);
9 }
     RequestAPKMsg.java 
01 package com.zlc.all;
02  
03 /**
04  * 具体算法类：APKMsgRequest
05  * 请求apk详细信息
06  **/
07 public class RequestAPKMsg implements Request {
08  
09     @Override
10     public void requestFromeServer(String url) {
11         // TODO Auto-generated method stub
12         System.out.println("1:请求apk信息");
13         System.out.println("2:把数据通知给UI");
14         System.out.println("3:…………");
15     }
16  
17 }
    RequestDownload.java 
01 package com.zlc.all;
02 /**
03  * 具体算法类：RequestDownload
04  * 请求下载资源
05  **/
06 public class RequestDownload implements Request{
07     @Override
08     public void requestFromeServer(String url) {
09         // TODO Auto-generated method stub
10         System.out.println("1:请求apk/图片下载");
11         System.out.println("2:把数据保存到文件");
12         System.out.println("3:通知UI已经下载成功或失败");
13         System.out.println("4:…………");
14     }
15  
16 }
    RequestSearchMsg.java 
01 package com.zlc.all;
02 /**
03  * 具体算法类：RequestSearchMsg
04  * 请求搜索结果
05  * **/
06 public class RequestSearchMsg implements Request{
07     @Override
08     public void requestFromeServer(String url) {
09         // TODO Auto-generated method stub
10         System.err.println("1:请求搜索框输入的信息");
11         System.out.println("2:获取到的信息进行分页提示UI显示");
12         System.out.println("3:……………………");
13     }
14  
15 }
    RequestVersion.java 
01 package com.zlc.all;
02 /**
03  * 具体算法类：RequestVersion
04  * 请求版本信息
05  **/
06 public class RequestVersion implements Request{
07     @Override
08     public void requestFromeServer(String url) {
09         // TODO Auto-generated method stub
10         System.out.println("1:请求该应用版本信息");
11         System.out.println("2:与本身应用的版本进行比较");
12         System.out.println("3:通知UI显示是否更新对话框");
13         System.out.println("4:…………………………");
14     }
15  
16 }
   RequestContext.java 
01 package com.zlc.stratery;
02  
03 import com.zlc.all.Request;
04 /**
05  * 环境角色类：RequestContex
06  * 持有一个Request类的引用
07  **/
08 public class RequestContext {
09     private Request request;
10     public RequestContext(Request request) {
11         // TODO Auto-generated constructor stub
12         this.request = request;
13     }
14     public void requestFromServer(String url){
15         request.requestFromServer(url);
16     }
17 }
  UIClient.java 
01 package com.zlc.stratery;
02  
03 import com.zlc.all.RequestAPKMsg;
04 import com.zlc.all.RequestChoise;
05 import com.zlc.all.RequestDownload;
06 import com.zlc.all.RequestSearchMsg;
07 import com.zlc.all.RequestVersion;
08  
09 public class UIClient {
10     String  msg = "";
11     RequestContext context;
12     public void questMsg(RequestChoise choise,String url){
13         switch (choise) {
14         case REQUEST_APK_MSG:
15             context = new RequestContext(new RequestAPKMsg());
16             break;
17         case REQEUST_APK_IMG_DOWNLOAD:
18             context = new RequestContext(new RequestDownload());
19             break;
20         case REQUEST_VERSION:
21             context = new RequestContext(new RequestVersion());
22             break;
23         case REQUEST_SEARCH_MSG:
24             context = new RequestContext(new RequestSearchMsg());
25             break;
26         default:
27             break;
28         }
29         context.requestFromServer(url);
30     }
31 }
策略模式优点：  
     （1） 策略模式提供了管理相关的算法族的办法，策略类的等级结构定义了一个算法或行为族，恰当的使用继承可以把公共的代码移植带父类里面去，从而减少了代码的重复。 
     （2） 策略模式提供了可以替换继承关系的办法。继承可以处理多种算法或行为。如果不是用策略模式，那么使用算法或行为的环境类就可能会有一些子类（使用环境类一个子类对应一种算法类），每一个子类提供一个不同的算法或行为。但是，这样一来算法或行为的使用者就和算法或行为本身混在一起。决定使用哪一种算法或采取哪一种行为的逻辑就和算法或行为的逻辑混合在一起，从而不可能再独立演化。继承使得动态改变算法或行为变得不可能。 
     （3） 使用策略模式可以避免使用多重条件转移语句（if……else）。多重转移语句不易维护，它把采取哪一种算法或采取哪一种行为的逻辑与算法或行为的逻辑混合在一起，统统列在一个多重转移语句里面，比使用继承的办法还要原始和落后。
缺点：  
     （1） 客户端必须知道所有的策略类（  下面通过简单工厂+策略模式解决这个问题 ），并自行决定使用哪一个策略类。这就意味着客户端必须理解这些算法的区别，以便适时选择恰当的算法类。换言之，策略模式只适用于客户端知道所有的算法或行为的情况（  可以通过反射解决这个问题 ）。 

    （2）策略模式造成很多的策略类。有时候可以通过把依赖于环境的状态保存到客户端里面，而将策略类设计成可共享的，这样策略类实例可以被不同客户端使用。换言之，可以使用享元模式来减少对象的数量。

3）简单工厂+策略模式
    把客户端的方法（switch部分）移植到环境类里面去。
    环境角色类：RequestContext------持有一个Request类的引用，提供具体算法调用接口
    UI客户端：   UIClient-------------请求发起、调用者
    其他同上

    RequestContext

01 package com.zlc.strategy.factory;
02  
03 import com.zlc.all.Request;
04 import com.zlc.all.RequestAPKMsg;
05 import com.zlc.all.RequestChoise;
06 import com.zlc.all.RequestDownload;
07 import com.zlc.all.RequestSearchMsg;
08 import com.zlc.all.RequestVersion;
09 /**
10  * 环境角色类：RequestContex
11  * 持有一个Request类的引用
12  **/
13 public class RequestContext {
14     private Request request;
15     public RequestContext(RequestChoise choise) {
16         switch (choise) {
17         case REQUEST_APK_MSG:
18             request = new RequestAPKMsg();
19             break;
20         case REQEUST_APK_IMG_DOWNLOAD:
21             request = new RequestDownload();
22             break;
23         case REQUEST_VERSION:
24             request = new RequestVersion();
25             break;
26         case REQUEST_SEARCH_MSG:
27             request = new RequestSearchMsg();
28             break;
29         default:
30             break;
31         }
32     }
33     public void requestFromServer(String url){
34         request.requestFromServer(url);
35     }
36 }
    UIClietn.java 
01 package com.zlc.strategy.factory;
02  
03 import com.zlc.all.RequestChoise;
04  
05 public class UIClient {
06     String  msg = "";
07     RequestContext context;
08     public void questMsg(RequestChoise choise,String url){
09         context = new RequestContext(choise);
10         context.requestFromServer(url);
11     }
12 }
这样客户端的代码就更少了，也大大降低了代码的耦合性，客户端不需要涉及详细的算法类，更方便与维护。


4）反射+策略模式
    环境角色类：RequestContext------持有一个Request类的引用，提供具体算法调用接口
    UI客户端：   UIClient-------------请求发起、调用者
    其他同上

    RequestContext.java

01 package com.zlc.reflect;
02  
03 import com.zlc.all.Request;
04 /**
05  * 环境角色类：RequestContex
06  * 持有一个Request类的引用
07  **/
08 public class RequestContext {
09     private Request request;
10     public RequestContext(String fileName) {
11         // TODO Auto-generated constructor stub
12         Class clazz ;
13         try {
14             clazz = Class.forName(fileName);
15             request = (Request)clazz.newInstance();
16         } catch (Exception e) {
17             // TODO Auto-generated catch block
18             e.printStackTrace();
19         }
20          
21     }
22     public void requestFromServer(String url){
23         request.requestFromServer(url);
24     }
25 }
    UIClient.java 
01 package com.zlc.reflect;
02  
03  
04 public class UIClient {
05     String  msg = "";
06     RequestContext context;
07     public void questMsg(String url,String fileName){
08         context = new RequestContext(fileName);
09         context.requestFromServer(url);
10     }
11 }
这样，选择分支结构也去掉了。 
策略模式（Strategy）：它定义了算法家族，分别封装起来，让他们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的用户。

最后说一下策略模式和简单工厂之间的区别：
    （1）策略模式的具体算法类对象是在使用者类里面进行创建的，然后传递给环境类（管理一个父类算法对象），简单工厂是通过使用者提供的条件在工厂类里面创建。
    （2）策略模式具体是算法行为是通过环境类Context提供的接口调用，简单工厂是通过返回给调用者所需要的对象，然后由返回对象直接调用。

morningsun1990
关注
专栏目录
设计模式-策略模式在Java中的使用示例
BADAO_LIUMANG_QIZHI的博客
10-31 1079
是指定义了算法家族并分别封装起来，让它们之间可以互相替换，此模式使得算法的变化不会影响使用算法的用户。策略模式的应用场景1、系统中有很多类，而它们的区别仅仅在于行为不同。2、一个系统需要动态地在几种算法中选择一种。注：博客：关注公众号霸道的程序猿获取编程相关电子书、教程推送与免费下载。
55-Java设计模式之策略模式与状态模式1
08-08
Java 设计模式之策略模式与状态模式 策略模式是 Java 中的一种设计模式，它主要用于解决系统与第三方接口进行数据交互的问题。当系统需要与多种格式的数据进行交互时，使用策略模式可以很好地解决这个问题。例如，...
Java中的策略设计模式
最佳 Java 编程
06-13 139
策略设计模式是一种行为模式，其中我们有多种算法/策略来完成一项任务，并使用哪种算法/策略留给客户选择。 各种算法选项封装在单独的类中。 在本教程中，我们将学习在Java中实现策略设计模式。 UML表示形式： 首先，我们来看一下策略设计模式的UML表示形式： 在这里，我们有： 策略：定义我们打算执行的常见操作的界面 ConcreteStrategy：这些是使用不同算法来...
设计模式-策略模式
weixin_33885253的博客
05-09 94
2019独角兽企业重金招聘Python工程师标准>>> ...
Java 策略设计模式
D.K专栏
07-21 543
策略设计模式属于对象的行为模式。其用意是针对一组算法，将每一个算法封装到具有共同的接口的独立类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生。 策略模式的结构 策略模式是对算法的包装，是把使用算法的责任和算法本身分割开来，委派给不同的对象进行管理。策略模式通常把一个系列的算法包装到一些列的策略类里面，作为一个抽象的策略类的子类。 策略模式举例：
java 策略设计模式
moliyiran的专栏
12-06 158
package Fill.vice.test; import java.util.Date; //策略设计模式 //面向接口编程 /** * * @author liufeihong *oo编程原则: *a.面向接口编程 *b.封装变化 *c.多用组合，少用继承 */ public class TestDemo { public static void main(String[]
Java 经典设计模式讲解以及项目实战
06-14
Java 经典设计模式讲解以及项目实战 设计模式简介：主要介绍各种设计模式的概念和运用场景等 设计模式综合运用：主要是笔者在实际工作中运用到的一些设计模式综合运用事例的提炼 Spring设计模式简介：主要是讲述...
java常用设计模式-策略模式
最新发布
08-28
策略模式是一种行为型设计模式，它允许您定义一系列算法，将每个算法封装起来，并使它们可以互换使用。这种模式使得算法可以独立于使用它们的客户端而变化。在 Java 中，策略模式通常由一个接口和多个实现该接口的类...
重学java的设计模式
05-09
Java作为一门广泛应用的开发语言，其设计模式的应用对于提高代码质量、可维护性和可扩展性至关重要。本文将着重探讨创建型模式、结构型模式和行为模式这三大类设计模式，并结合六项设计原则进行深入解析。 首先，...
java 策略设计模式_java策略设计模式
weixin_32252929的博客
02-12 62
有了接口，那么实现类在哪里呢？还是在ThreadPoolExecutor类中，只是使用了静态内部类的形式：public static class CallerRunsPolicy implementsRejectedExecutionHandler {publicCallerRunsPolicy() { }public voidrejectedExecution(Runnable r, Threa...
JAVA策略设计模式：Strategy
wangking:开源世界，人人都用上了正版啦。。。
12-13 105
  博主 写道 策略模式的用意是针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。使用策略模式可以把行为和环境分割开来。环境类负责维持和查询行为类，各种算法则在具体策略中提供。由于算法和环境独立开来，算法的修改都不会影响环境和客户端   策略模式： 由三部分组成 A:  抽象策略角色：策略类，通...
java 策略设计模式_java设计模式--策略模式
weixin_39820588的博客
02-12 79
策略模式：定义了不同的算法，分别分装起来，让他们可以互相替换，即使算法变化了，也不会影响到使用算法的用户首先定义一个抽象算法类，有两个类继承了这个抽象类，重写了AlgorithmInterface()方法public abstract classStrategy {public abstract voidAlgorithmInterface();}public class AlgorithmA e...
java 策略设计模式_Java设计模式：策略模式
weixin_39904587的博客
02-16 72
策略模式，顾名思义，我是没看懂。不知道为什么称它为策略模式，但通过学习，我知道这种模式可以让我的代码分工明确，实现了操作和使用者的解耦。策略模式共分三个部分：1.你的操作方法的接口，定义了一个实现的方法2.你的操作方法的具体实现3.环境类，用来对具体的操作方法进行设置，比如执行等举个栗子????！需求：我有三个算法，分别可以解决三个问题，那么我得看看问题是什么来选用不同的方法。解决方法1:int que...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值