精华内容
下载资源
问答
  • java策略模式典型案例

    万次阅读 多人点赞 2019-05-25 00:32:21
    以一个顾客价格计算策略为背景,写一个策略模式的demo 参考代码 :https://github.com/zhang-xiaoxiang/DesignPatterns23 没有用策略模式我们一般是下面的写法,直接写一个类,在类里面直接写策略算法(功能实现) //...

    以一个顾客价格计算策略为背景,写一个策略模式的demo参考代码 : https://github.com/zhang-xiaoxiang/DesignPatterns23

    日常碰到的业务概述

    登录类型,支付类型,供应商渠道,不同等级会员享受的优惠券价格不一样,等等业务判断,大量if else导致拓展(侧重新增)极其困难,维护(侧重修改)自然是改起来头痛(其实一个类型的增加[拓展一个类型]往往对应这个类型的增删改查CRUD[维护]),比如业务一开始一个简单的登录,往往做一个电话号码和验证码登录的方式或者账号密码登录方式,后来随着业务的增加或者提高用户体验,那么需要拓展(新增一种)三方登录,比如新增微信登录,支付宝登录,甚至抖音登录,一大堆,你要根据登录方式来处理,那就有点恼火吧,支付方式也是同样的问题,我们可以发现一个规律,凡是可以枚举的业务,往往都需要使用设计模式才能更好的解决,比如策略模式(往往搭配工厂模式使用更配哦),水来土掩,兵来将挡,这思想和高中数学中的分类讨论思想一模一样.遇事不要慌,因为还有dang中央.所以,我们就打个栗子,举个比方,更加形象一点,

    没有用策略模式

    我们一般是下面的写法,直接写一个类,在类里面直接写策略算法(功能实现)

    //package com.demo.strategy;
    
    /**
     * NoStrategy:没有策略的做法
     * 实现起来比较容易,符合一般开发人员的思路
     * 假如,类型特别多,算法比较复杂时,整个条件语句的代码就变得很长,难于维护。
     * 如果有新增类型,就需要频繁的修改此处的代码!
     * 不符合开闭原则!---对这个类的修改要关闭,就是这个类要是写好了就不要去改他了,对类的功能的拓展要开放,显然只有面向接口编程才满足,
     * 所以策略模式Strategy这个接口(文中涉及到的)就应运而生了晒哈哈哈
     * @author zhangxiaoxiang
     * @date: 2019/05/24
     */
    public class NoStrategy {
    	/**
    	 * 传入客服等级类型获取相应的价格
    	 * @param type   会员类型(等级)
    	 * @param price  响应的价格
    	 * @return
    	 */
    	public double getPrice(String type, double price) {
    
    		if ("普通客户小批量".equals(type)) {
    			System.out.println("[未采用设计模式] 不打折,原价");
    			return price;
    		} else if ("普通客户大批量".equals(type)) {
    			System.out.println("[未采用设计模式] 打九折");
    			return price * 0.9;
    		} else if ("老客户小批量".equals(type)) {
    			System.out.println("[未采用设计模式] 打八折");
    			return price * 0.8;
    		} else if ("老客户大批量".equals(type)) {
    			System.out.println("[未采用设计模式] 打七折");
    			return price * 0.7;
    
    
    		//拓展一种策略
    		}else if("老客户特大批量".equals(type)){
    			System.out.println("[未采用设计模式] 打六折");
    			return price*0.6;
    		}
    
    
    		//乱传的也是当普通客户小批量(就是不打折)
    		return price;
    	}
    
    }
    

    策略模式

    看到上面的类,貌似想到一句话是不是,面向接口编程,上来就应该先是一个接口,所以改成接口

    1:面向接口编程,策略模式也是一样,上来先来个策略接口压压惊(领导先开会,把任务指明,通过策略获取价格)

    package com.demo.strategy;
    
    /**
     * Strategy:策略接口
     * 这个是对类NoStrategy改成面向接口的方式实现策略,不要像NoStrategy一样,
     * 直接写死策略的实现,而是使用这个接口先定义策略,功能实现后面再说
     * @author zhangxiaoxiang
     * @date 2019/5/24
     */
    public interface Strategy {
    	/**
    	 * 通过策略获取价格
    	 * @param standardPrice
    	 * @return
    	 */
    	 double getPrice(double standardPrice);
    }
    

    2:面向接口,组合编程,少用继承(继承虽然可以复用代码,但是会造成耦合度增加,解决方式往往采用接口做类的属性),如下,这样所有实现Strategy 的各种策略实现类都"组合"到这个类里面了,是不是所谓的高内聚啊

    //package com.demo.strategy;
    /**
     * Context:策略模式上下文---策略接收器,专门接收策略实现的算法
     * 负责和具体的策略类交互
     * 这样的话,具体的算法和直接的客户端调用分离了,使得算法可以独立于客户端独立的变化。
     * 如果使用spring的依赖注入功能,还可以通过配置文件,动态的注入不同策略对象,动态的切换不同的算法.
     * @author zhangxiaoxiang
     * @date: 2019/05/24
     */
    public class Context {
    	/**
    	 * 当前采用的算法对象
    	 * 面向接口,组合编程,少用继承
    	 * 简言之复杂类型(类,接口等)做属性
    	 */
    	private Strategy strategy;
    
    	/**
    	 * 选择策略Strategy实现类
    	 * 有参构造器(不写无参构造器,那么new 策略实现保证必须传一种策略,这里set方法也不用设置,
    	 * 设置了也没用(要设置set方法那么还是把无参构造也写出来才会有用,所以set伴随无参构造的感觉)
    	 * 这样同时也知道了为什么有参构造器设置了为什么无参构造器就失效了,JDK这样设计是有一定道理的,哈哈)
    	 * ---总之set注入也行,而且也推荐,也是一种组合/聚合的形式,只是这个例子采用构造器而已
    	 * @param strategy
    	 */
    	public Context(Strategy strategy) {
    		this.strategy = strategy;
    	}
    
    	public double getReultPrice(double price){
    		return this.strategy.getPrice(price);
    	}
    	//我的例子没有使用set方式注入而已,也可以使用它哈
    	// public void setStrategy(Strategy strategy) {
    	// 	this.strategy = strategy;
    	// }
    }
    
    

    3:既然是策略模式接口Strategy都明确了要做的事情是根据会员情况,返回价格,但是没有真正的实现,那么总有类来实现赛

    策略实现类1    VIP0Strategy 

    //package com.demo.strategy;
    /**
     * VIP0Strategy:普通会员策略
     *
     * @author zhangxiaoxiang
     * @date: 2019/05/24
     */
    public class VIP0Strategy implements Strategy {
    	/**
    	 * 输入一个价格,经过VIP0Strategy策略计算价格
    	 * @param standardPrice
    	 * @return
    	 */
    	@Override
    	public double getPrice(double standardPrice) {
    		System.out.println("[策略模式]普通会员 原价:"+standardPrice);
    		return standardPrice;
    	}
    
    }
    
    

     策略实现类2    VIP1Strategy 

    package com.demo.strategy;
    
    /**
     * VIP1Strategy: 一级会员策略
     *
     * @author zhangxiaoxiang
     * @date 2019/5/24
     */
    public class VIP1Strategy implements Strategy {
        /**
         * 输入一个价格,经过VIP1Strategy策略计算价格
         * @param standardPrice
         * @return
         */
        @Override
        public double getPrice(double standardPrice) {
            System.out.println("[策略模式]一级会员 打九折:"+standardPrice * 0.9);
            return standardPrice * 0.9;
        }
    
    }
    

    策略实现类3    VIP1Strategy 

    package com.demo.strategy;
    /**
     * VIP2Strategy:二级会员策略
     * @author zhangxiaoxiang
     * @date 2019/5/24
     */
    public class VIP2Strategy implements Strategy {
    	/**
    	 * 输入一个价格,经过VIP2Strategy策略计算价格
    	 * @param standardPrice
    	 * @return
    	 */
    	@Override
    	public double getPrice(double standardPrice) {
    		System.out.println("[策略模式]二级会员八折:"+standardPrice*0.8);
    		return standardPrice*0.8;
    	}
    
    }
    
    

     类似的策略实现类N ........随意拓展策略就是了

     客户端(使用者)使用----->后面加粗这段话可以忽略,也可以思考 客户端可以理解为前端传到后端的controller里面来了,我们设想,加入前端传入的需求(比如"普通客户大批量", 1000),那么仍然需要if else判断,因为这里需要选择策略,还是逃不掉选择困难症,如果已知前端的参数,那么这个策略也就知道了,就逃开if else的魔爪了,这也是策略模式的弊端(不过把所有策略通过IOC注入到一个map,然后使用get(入参),这样也是一种解决方式,不过不太优雅,反射+枚举估计是个不错的选择,老衲没有尝试的,有空再试),需要知道策略才行,不知道策略是谁,就不知道new 那个VIPNStrategy(),你仔细想一想是不是这个逻辑.至于new 策略可以使用spring 的IOC容器去做

    //package com.demo.strategy;
    
    /**
     * Client:策略模式客户端---Client 的main方法 可以想象成我们在使用别人写好的框架,我们有新的需求,对框架开发者来说就是需要对已有的
     * 代码进行维护升级,比如此时我们修改NoStrategy类,那么修改完后新版本的框架NoStrategy类很有能是对已经在使用的客户机制上不兼容的,如果
     * 用户升级为新版框架,遇到使用NoStrategy类的会报错,各种不兼容就不符合开发者维护的版本的规范,所以修改已有的类是极其不科学的
     *
     *
     * @author zhangxiaoxiang
     * @date: 2019/05/24
     */
    public class Client {
        public static void main(String[] args) {
            //System.out.println("------------------假如这里是service实现类,那么不知道使用哪种策略的就还是要根据参数new(或者spring IOC去取),感觉还是没有逃脱if else(所以结合工厂模式最佳啦,这个大伙可以思考一下,有空再更新这个博客)-----------------------");
            System.out.println("未使用模式-----------------------------------------");
            NoStrategy noStrategy=new NoStrategy();
            double price = noStrategy.getPrice("普通客户大批量", 1000);
            System.out.println(price);
            System.out.println("\n测试策略------------------------------------------");
            Context context0 = new Context(new VIP1Strategy());
            double resultPrice = context0.getReultPrice(1000);
            System.out.println(resultPrice);
    
    
            System.out.println("\n---怎么体现策略模式呢?比如现在需求是增加一种会员机制,  '老客户特大批量'  ,\n那么显然打折力度更大," +
                    "我们设置为6折,分别在未使用策略模式和使用了策略模式的基础上拓展,看那个更加易于拓展,方便维护---\n");
    
            //首先这这里,作为客户端只能够传入 "老客户特大批量" 和价格1000元,但是计算代码再服务器NoStrategy类里面,如果不去修改服务器NoStrategy
            //	那么这里是无法实现的,策略模式也是一样的,那么回到服务器端思考,不用设计模式就要修改NoStrategy里面的if else之类的代码,使用策略模式
            //    就要增加新的策略实现,其实差不太多
    
            //新增策略后未使用模式(会修该策略核心类)
            NoStrategy noStrategy1=new NoStrategy();
            double price1 = noStrategy1.getPrice("老客户特大批量", 1000);
            System.out.println(price1);
    
    
    
            //新增策略后使用模式(不会修改策略接口,只是添加一个实现)
            Context context2=new Context(new VPI4Strategy()) ;
            double price2 = context2.getReultPrice(1000);
            System.out.println(price2);
    
    
            System.out.println("\n结论:修改服务器端已经写好了的类是极其不好的维护形式,因为这个类NoStrategy" +
                    "\n可能在别的类中作为依赖或者叫做别的类引用了该类,在不明确的情况下,可能牵一发动全身,是不好的维护方式,使用了策略模式," +
                    "\n我们对只是添加了一个策略接口的实现,低侵入式,不会对已有代码造成影响,低耦合");
    
    
        }
    }
    

    使用模式的成果

    输出结果

     

    小结和抛出一些观点:上面基本已经完成策略模式的应用了,当然缺点就是调用端需要对策略有哪些熟悉,不知道的话就不能传入策略,所以这是最大的缺点.其实java的JDK8的函数式编程和Lambda表达式(简化匿名类等写法)可以让策略模式更加优雅,其实就是相当于JDK8新特性是把23中设计模式更加抽象的方式用在新语法上了,符合时代潮流,拓展java的函数式编程领域,可以大概参考哈新特性  https://zhangxiaoxiang.blog.csdn.net/article/details/100638661

    展开全文
  • java策略模式代码

    2014-02-06 16:00:24
    对应我博客的策略模式的源代码,可以参见我的博客!
  • java策略模式

    2014-10-26 22:35:46
    java策略模式,用代码讲述了其真实原理
  • 策略模式代码

    2014-05-13 19:23:28
    策略模式代码 java 策略模式 排序 泛型
  • java代码策略模式

    2016-12-15 16:04:26
    这是一个很好的资源
  • [size=medium][color=indigo]package com.oracleoaec.strategydemo; public class SortDemo { public static void main(String[] args) { ... int [] array={20,15,35,27,18,40,50,29};... BubbleSort bsort=n...
    [size=medium][color=indigo]package com.oracleoaec.strategydemo;

    public class SortDemo {

    public static void main(String[] args) {
    int [] array={20,15,35,27,18,40,50,29};
    BubbleSort bsort=new BubbleSort();
    SelectSort ssort=new SelectSort();
    Context1 context1=new Context1(bsort);
    Context1 context2=new Context1(ssort);
    context1.sort(array);
    context1.print(array);
    context2.sort(array);
    context2.print(array);
    }

    }
    class Context1{
    private Isort isort=null;
    public Context1(Isort isort){
    this.isort=isort;
    }
    public void sort(int [] array){
    isort.sort(array);
    }
    public void print(int [] array){
    for(int i=0;i<array.length;i++){
    System.out.print(array[i]+" ");
    }
    System.out.println();
    }
    }
    interface Isort{
    public abstract void sort(int [] array);
    }
    class BubbleSort implements Isort{
    @Override
    public void sort(int[] array) {
    System.out.println("冒泡排序法");
    for(int i=0;i<array.length-1;i++){
    for(int j=0;j<array.length-1-i;j++){
    if(array[j]>array[j+1]){
    int temp=array[j];
    array[j]=array[j+1];
    array[j+1]=temp;
    }
    }
    }
    }

    }
    class SelectSort implements Isort{
    @Override
    public void sort(int[] array) {
    System.out.println("选择排序法");
    for(int i=0;i<array.length;i++){
    int min=i;
    for(int j=i+1;j<array.length;j++){
    if(array[min]>array[j]){
    min=j;
    }
    }
    if(min!=i){
    int temp=array[min];
    array[min]=array[i];
    array[i]=temp;
    }
    }
    }

    }[/color][/size]
    展开全文
  • 策略设计模式: Dock超类: package com.hycz.design.pattern.strategy; import com.hycz.design.pattern.strategy.behavioral.FlyBehavior; import ...



    策略设计模式:



    Dock超类:

    package com.hycz.design.pattern.strategy;
    
    import com.hycz.design.pattern.strategy.behavioral.FlyBehavior;
    import com.hycz.design.pattern.strategy.behavioral.QuackBehavior;
    
    /**
     * Created with IntelliJ IDEA.
     * User: shangke
     * Date: 6/13/13
     * Time: 10:13 AM
     * To change this template use File | Settings | File Templates.
     */
    public abstract class Duck {
    
        public FlyBehavior flyBehavior;
        public QuackBehavior quackBehavior;
    
        public void setFlyBehavior(FlyBehavior flyBehavior) {
            this.flyBehavior = flyBehavior;
        }
    
        public void setQuackBehavior(QuackBehavior quackBehavior) {
            this.quackBehavior = quackBehavior;
        }
    
        public abstract void dispaly();
    
        public void swim(){
            System.out.printf("All duck float, even decoys!");
        }
        public void performFly(){
            flyBehavior.fly();
    
        }
        public void performQuack(){
            quackBehavior.quack();
        }
    
    
    
    }
    

    package com.hycz.design.pattern.strategy.behavioral;
    
    /**
     * Created with IntelliJ IDEA.
     * User: shangke
     * Date: 6/13/13
     * Time: 10:16 AM
     * To change this template use File | Settings | File Templates.
     */
    public interface FlyBehavior {
    
        public void fly();
    }
    

    package com.hycz.design.pattern.strategy.behavioral;
    
    /**
     * Created with IntelliJ IDEA.
     * User: shangke
     * Date: 6/13/13
     * Time: 10:49 AM
     * To change this template use File | Settings | File Templates.
     */
    public class FlyNoWings implements FlyBehavior {
        @Override
        public void fly() {
            System.out.println("I'm can't fly !");
        }
    }
    

    package com.hycz.design.pattern.strategy.behavioral;
    
    /**
     * Created with IntelliJ IDEA.
     * User: shangke
     * Date: 6/13/13
     * Time: 10:47 AM
     * To change this template use File | Settings | File Templates.
     */
    public class FlyWithWings implements FlyBehavior {
        @Override
        public void fly() {
            System.out.println("I'm flying !");
        }
    }
    

    package com.hycz.design.pattern.strategy.behavioral;
    
    /**
     * Created with IntelliJ IDEA.
     * User: shangke
     * Date: 6/13/13
     * Time: 10:16 AM
     * To change this template use File | Settings | File Templates.
     */
    public interface QuackBehavior {
    
        public void quack();
    }
    

    package com.hycz.design.pattern.strategy.behavioral;
    
    /**
     * Created with IntelliJ IDEA.
     * User: shangke
     * Date: 6/13/13
     * Time: 10:50 AM
     * To change this template use File | Settings | File Templates.
     */
    public class Quack implements QuackBehavior {
        @Override
        public void quack() {
            System.out.println("Quack !");
        }
    }
    

    package com.hycz.design.pattern.strategy;
    
    import com.hycz.design.pattern.strategy.behavioral.FlyNoWings;
    import com.hycz.design.pattern.strategy.behavioral.Quack;
    
    /**
     * Created with IntelliJ IDEA.
     * User: shangke
     * Date: 6/13/13
     * Time: 10:55 AM
     * To change this template use File | Settings | File Templates.
     */
    public class ModelDuck extends Duck {
    
        public ModelDuck() {
            flyBehavior = new FlyNoWings();
            quackBehavior = new Quack();
        }
    
        @Override
        public void dispaly() {
            System.out.println("I'm a model duck !");
        }
    }
    

    package com.hycz.design.pattern.strategy;
    
    /**
     * Created with IntelliJ IDEA.
     * User: shangke
     * Date: 6/13/13
     * Time: 10:57 AM
     * To change this template use File | Settings | File Templates.
     */
    public class MiniDuckSimulator {
    
        public static void main(String[] args) {
            Duck model = new ModelDuck();
            model.dispaly();
            model.performFly();
            model.performQuack();
    
    
    
        }
    }
    


    展开全文
  • java策略模式小例子

    2014-04-26 10:58:44
    java策略模式的小例子,学习java策略模式的简单例子,代码虽然简单不错很容易明白
  • java策略模式示例.zip

    2019-09-26 16:02:39
    java策略模式示例代码,用于初学者学习使用,示例简单易懂
  • 为了支持生成状态模式类和策略模式类,该项目的代码已移至新项目StrategyStateGenerator(https://sourceforge.net/projects/strategystategenerator/)。 StrategyStateGenerator项目提供了Strategy Pattern和...
  • Java 策略模式

    2019-07-26 12:46:08
    当遇到一个问题多种解决时,最简单的方式是利用if-else或switch-case根据不同判断选择不同方案,但这种方式代码耦合性太高、代码臃肿、难以维护等,这时可以利用策略模式将各种方案分离开,根据具体需求选择不同的...

    策略模式

    特点

    • 策略模式定义了一系列的算法,并将每一个算法封装起来,它们之间可以互相替换。

    • 当遇到一个问题多种解决时,最简单的方式是利用if-else或switch-case根据不同判断选择不同方案,但这种方式代码耦合性太高、代码臃肿、难以维护等,这时可以利用策略模式将各种方案分离开,根据具体需求选择不同的策略方案。

    角色介绍

    • Context:操作策略的上下文环境。
    • Strategy:抽象策略。
    • ConcreteStrategy:具体策略方案。

    代码实现

    使用传统if-else方式

    public class PriceCalculator {
        public static final int TYPE_BUS = 1;
        public static final int TYPE_SUBWAY = 2;
    
        /**
         * 公交车计费
         * 10km以内1元钱,超过10km部分每5km加1元
         */
        private int busPrice(int km) {
            int price = 1;
            //超出10km的距离
            int extraTotal = km - 10;
            int extraParts = extraTotal / 5;
            extraParts = extraTotal % 5 > 0 ? ++extraParts : extraParts;
            price += extraParts * 1;
            return price;
        }
    
        /**
         * 地铁计费
         * 6km(含)以内3元,6-12(含)km4元,12-22km(含)5元,22-32km(含)6元,其他距离7元
         */
        private int sbuwayPrice(int km) {
            if (km <= 6) {
                return 3;
            } else if (km > 6 && km <= 12) {
                return 4;
            } else if (km > 12 && km <= 22) {
                return 5;
            } else if (km > 22 && km <= 32) {
                return 6;
            } else {
                return 7;
            }
        }
    
        public int calculatorPrice(int km, int type) {
            if (type == TYPE_BUS) {
                return busPrice(km);
            } else if (type == TYPE_SUBWAY) {
                return sbuwayPrice(km);
            } else {
                return 0;
            }
        }
    }
    

    使用

    public class Demo {
        public static void main(String[] args) {
            PriceCalculator calculator = new PriceCalculator();
            System.out.println(calculator.calculatorPrice(16, PriceCalculator.TYPE_SUBWAY));//5
            System.out.println(calculator.calculatorPrice(16, PriceCalculator.TYPE_BUS));//3
        }
    }
    

    使用策略模式优化

    策略接口

    interface CalculateStrategy {
        int calculatePrice(int km);
    }
    

    具体策略

    public class BusStrategy implements CalculateStrategy {
        @Override
        public int calculatePrice(int km) {
            /**
             * 公交车计费
             * 10km以内1元钱,超过10km部分每5km加1元
             */
            int price = 1;
            //超出10km的距离
            int extraTotal = km - 10;
            int extraParts = extraTotal / 5;
            extraParts = extraTotal % 5 > 0 ? ++extraParts : extraParts;
            price += extraParts * 1;
            return price;
        }
    }
    
    public class SubwayStrategy implements CalculateStrategy {
        @Override
        public int calculatePrice(int km) {
            /**
             * 地铁计费
             * 6km(含)以内3元,6-12(含)km4元,12-22km(含)5元,22-32km(含)6元,其他距离7元
             */
            if (km <= 6) {
                return 3;
            } else if (km > 6 && km <= 12) {
                return 4;
            } else if (km > 12 && km <= 22) {
                return 5;
            } else if (km > 22 && km <= 32) {
                return 6;
            } else {
                return 7;
            }
        }
    }
    

    操作策略的上下文对象

    public class TrafficCalculator {
        CalculateStrategy calculator = null;
    
        public void setCalculator(CalculateStrategy calculator) {
            this.calculator = calculator;
        }
    
        public int calculatePrice(int km) {
            return calculator.calculatePrice(km);
        }
    }
    

    使用

    public class Demo {
        public static void main(String[] args) {
            TrafficCalculator calculator = new TrafficCalculator();
            // calculator.setCalculator(new BusStrategy());
            calculator.setCalculator(new SubwayStrategy());
            System.out.println(calculator.calculatePrice(16));
        }
    }
    
    5
    
    展开全文
  • java 策略模式

    2018-08-16 09:57:14
    如果在一个条件语句中又包含了多个条件语句就会使得代码变得臃肿,维护的成本也会加大,而策略模式就能较好的解决这个问题,本篇博客就带你详细了解策略模式策略模式的定义和使用场景 定义:策略模式定义了一...
  • 策略模式:一个类的行为或其算法可以在运行时更改。应用场景:1、当有很多类似的类,但执行某些行为的方式不同时。 2、动态地在几种算法中选择一种。 public class StrategyPattern { public static void main...
  • 前言:如果策略模式的...JAVA语言版策略模式 创建策略接口: public interface Strategy { public int doOperation(int num1, int num2); } 创建接口实现类 public class OperationAdd implements Strategy...
  • 主要介绍了Java利用策略模式优化过多if else代码,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • Java策略模式

    2018-03-08 11:46:12
    参考headfirst设计模式设计原则:找出应用中可能需要变化之外,把它们独立出来,不要和那些不需要变化的代码混在一起设计原则:针对接口编程,而不是针对实现编程设计原则:多用组合,少用继承策略模式定义了算法族,...
  • Java策略模式实例

    2020-03-25 17:14:11
    Java策略模式实例一、前言二、需求三、代码结构图总体UML如下:具体流程四、小结 一、前言 最近写代码发现,业务逻辑很多的时候,总会有很多的if ... else。会导致有时候丢失某些逻辑。 有的时候也会用到switch ...
  • java策略模式实战

    千次阅读 2018-03-06 14:13:15
    项目:保险场景:保险业务中涉及计费的问题,每种保险的计费策略不同,为了更好的代码维护,参考大神写的java策略模式后为选择了策略模式设计了编码方案。涉及表:产品方案表业务简介:每个保险产品对应不同的方案,...
  • java策略模式与Spring整合 2017年07月28日 17:19:53 苹果树上的你 阅读数:490 标签: java设计模式策略模式策略模式与Sprin 更多 个人分类: java设计模式 java设计模式有很多种,其中策略模式算是比较...
  • 在基本的策略模式中,选择所用具体实现的职责由客户端对象承担,并转给策略模式的Context对象。 优点 1.策略模式是一种定义了一系列算法的方法,从概念上来看,所有这些算法完成的都是相同的工作,只是实现不同,它...
  • 主要介绍了Java策略模式实现简单地购物车,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 一个策略模式的小例子,比较直观的体现出设计模式的魅力。 先看需求:一个用户表,含有 【名称、年龄 、分数】 字段。现有一个用户集合, 需求1:获取年龄大于30岁的用户都是谁 需求2:获取年龄小于30虽的用户都...
  • 【设计模式】策略模式demo,用java实现的,简单易懂,亲测有效

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,943
精华内容 777
关键字:

java策略模式代码

java 订阅