设计模式--策略模式

最新推荐文章于 2023-12-14 10:57:27 发布
最新推荐文章于 2023-12-14 10:57:27 发布
阅读量129 收藏 1
点赞数
分类专栏： 后端面试题 文章标签： 20.4.12 0.27PM 设计模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42061487/article/details/105463163
版权

策略模式

问题引出（鸭子问题）

  1. 有各种鸭子（比如 野鸭，北京鸭，水鸭等，鸭子有各种行为，比如叫，飞行等）
  2. 显示鸭子的信息

传统方案解决鸭子问题的分析和代码实现

  1. 传统方案设计类图
    在这里插入图片描述
    代码实现
package com.gduf.strategy;

/**
 * @Author 晨边#CB
 * @Date:created in  2020/4/11 23:29
 * @Version V1.0
 **/

public abstract class Duck {

    public Duck(){

    }

    public abstract void display();//显示鸭子信息

    public void quack(){
        System.out.println("鸭子嘎嘎叫~~");
    }

    public void swim(){
        System.out.println("鸭子会游泳~~");
    }

    public void fly(){
        System.out.println("鸭子会飞~~");
    }

}


package com.gduf.strategy;

/**
 * @Author 晨边#CB
 * @Date:created in  2020/4/11 23:32
 * @Version V1.0
 **/

public class PekingDuck extends Duck {
    @Override
    public void display() {
        System.out.println(" 北京鸭~~");
    }

    //因为北京鸭不能飞翔，因此需要重写fly

    @Override
    public void fly() {
        System.out.println("北京鸭不能飞翔");
    }
}


package com.gduf.strategy;

/**
 * @Author 晨边#CB
 * @Date:created in  2020/4/11 23:33
 * @Version V1.0
 **/

public class ToyDuck extends Duck {
    @Override
    public void display() {
        System.out.println("玩具鸭~~");
    }

    //需要重写父类的所有方法
    public void quack(){
        System.out.println("玩具鸭不会嘎嘎叫~~");
    }

    public void swim(){
        System.out.println("玩具鸭不会游泳~~");
    }

    public void fly(){
        System.out.println("玩具鸭不会飞~~");
    }

}


package com.gduf.strategy;

/**
 * @Author 晨边#CB
 * @Date:created in  2020/4/11 23:31
 * @Version V1.0
 **/

public class WildDuck extends Duck {
    @Override
    public void display() {
        System.out.println(" 这是野鸭");
    }
}

传统方式解决鸭子问题分析和解决方案

  1. 其他鸭子，都继承了Duck类，所以fly让所有子类都会飞，这是不正确的
  2. 上面说的1的问题，其实都是继承带来的问题：对类的局部改动，尤其超类的局部改动，会影响其他部分。会有溢出效应
  3. 为了改进1问题，我们可以通过覆盖fly 方法来解决=>覆盖解决
  4. 问题又来了，如果我们有一个玩具鸭子ToyDuck ，这样就需要ToyDuck去实现Duck的所有实现的方法 => 解决思路 策略模式

策略模式的基本介绍

  1. 策略模式中，定义算法族(策略组)，分别封装起来，让他们之间可以相互替换，此模式让算法的变化独立于使用算法的客户
  2. 这算法体现了几个设计原则，第一：把变化的代码从不变的代码种分离出来；第二：针对接口编程而不是具体类（定义了策略接口）；第三：多用组合/聚合，少用继承（客户通过组合方式使用策略）

策略模式的原理类图
思路分析：分别封装行为接口，实现算法族，超类里面方行为接口对象，在子类里具体设定行为对象。原则就是：分离变化部分，封装接口，基于接口编程各种功能，此模式让行为的变化独立于算法的使用者
在这里插入图片描述
说明：从上图可以看到，客户context有成员变量strategy或者其他的策略接口，至于需要使用到哪个策略，我们可以在构造器中指定。
类图分析
在这里插入图片描述

代码实现

package com.gduf.strategy.improve;

/**
 * @Author 晨边#CB
 * @Date:created in  2020/4/11 23:55
 * @Version V1.0
 **/

public class BadFlyBehavior implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("飞翔技术一般~~");
    }
}


package com.gduf.strategy.improve;

/**
 * @Author 晨边#CB
 * @Date:created in  2020/4/11 23:59
 * @Version V1.0
 **/

public class Client {
    public static void main(String[] args) {
        WildDuck wildDuck = new WildDuck();
        wildDuck.fly();

        ToyDuck toyDuck = new ToyDuck();
        toyDuck.fly();

        PekingDuck pekingDuck = new PekingDuck();
        pekingDuck.fly();

        //动态改变某个对象的行为,北京鸭不能飞
        pekingDuck.setFlyBehavior(new NoFlyBehavior());
        System.out.print("北京鸭的实际飞翔能力：");
        pekingDuck.fly();
    }
}


package com.gduf.strategy.improve;

/**
 * @Author 晨边#CB
 * @Date:created in  2020/4/11 23:29
 * @Version V1.0
 **/

public abstract class Duck {

    //属性，策略接口
    FlyBehavior flyBehavior;
    //其他属性<->策略接口
    QuackBehavior quackBehavior;

    public Duck(){

    }

    public abstract void display();//显示鸭子信息

    public void quack(){
        System.out.println("鸭子嘎嘎叫~~");
    }

    public void swim(){
        System.out.println("鸭子会游泳~~");
    }

    public void fly(){
        //改进
        if (flyBehavior!=null){
            flyBehavior.fly();
        }
    }

    public void setFlyBehavior(FlyBehavior flyBehavior) {
        this.flyBehavior = flyBehavior;
    }

    public void setQuackBehavior(QuackBehavior quackBehavior) {
        this.quackBehavior = quackBehavior;
    }
}


package com.gduf.strategy.improve;

/**
 * @Author 晨边#CB
 * @Date:created in  2020/4/11 23:54
 * @Version V1.0
 **/
public interface FlyBehavior {

    void fly();//子类具体实现
}


package com.gduf.strategy.improve;

/**
 * @Author 晨边#CB
 * @Date:created in  2020/4/11 23:54
 * @Version V1.0
 **/

public class GoodFlyBehavior implements FlyBehavior{
    @Override
    public void fly() {
        System.out.println(" 飞翔技术高超~~~");
    }
}


package com.gduf.strategy.improve;

/**
 * @Author 晨边#CB
 * @Date:created in  2020/4/11 23:55
 * @Version V1.0
 **/

public class NoFlyBehavior implements FlyBehavior{
    @Override
    public void fly() {
        System.out.println(" 不会飞翔~~");
    }
}


package com.gduf.strategy.improve;

/**
 * @Author 晨边#CB
 * @Date:created in  2020/4/11 23:32
 * @Version V1.0
 **/

public class PekingDuck extends Duck {

    //假如北京鸭可以飞翔，但是飞翔技术一般
    public PekingDuck(){
        flyBehavior = new BadFlyBehavior();
    }

    @Override
    public void display() {
        System.out.println(" 北京鸭~~");
    }

    //因为北京鸭不能飞翔，因此需要重写fly

}


package com.gduf.strategy.improve;

/**
 * @Author 晨边#CB
 * @Date:created in  2020/4/12 0:03
 * @Version V1.0
 **/
public interface QuackBehavior {

    void quack();//子类实现

}


package com.gduf.strategy.improve;

/**
 * @Author 晨边#CB
 * @Date:created in  2020/4/11 23:33
 * @Version V1.0
 **/

public class ToyDuck extends Duck {

    public ToyDuck(){
        flyBehavior = new NoFlyBehavior();
    }

    @Override
    public void display() {
        System.out.println("玩具鸭~~");
    }

    //需要重写父类的所有方法
    public void quack(){
        System.out.println("玩具鸭不会嘎嘎叫~~");
    }

    public void swim(){
        System.out.println("玩具鸭不会游泳~~");
    }

}


package com.gduf.strategy.improve;

/**
 * @Author 晨边#CB
 * @Date:created in  2020/4/11 23:31
 * @Version V1.0
 **/

public class WildDuck extends Duck {

    //构造器，传入FlyBehavior的对象
    public WildDuck() {
        flyBehavior = new GoodFlyBehavior();
    }

    @Override
    public void display() {
        System.out.println(" 这是野鸭");
    }
}

策略模式在JDK-Arrays应用的源码分析
在这里插入图片描述

package com.gduf.jdk;

import java.util.Arrays;
import java.util.Comparator;

/**
 * @Author 晨边#CB
 * @Date:created in  2020/4/12 0:05
 * @Version V1.0
 **/

public class Strategy {
    public static void main(String[] args) {
        Integer[] data = {9,1,2,8,4,3};
        //实现升序排序，返回-1放左边，1放右边，0保持不变

        //说明
        //1.实现Comparator接口,匿名类对象 new Comparator<Integer>() {
        //2.对象 new Comparator<Integer>() { 就是实现了策略接口的对象
        //3.public int compare(Integer o1,Integer o2){} 指定具体的处理方式
        Comparator<Integer> comparator = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                if(o1>o2){
                    return 1;
                }else {
                    return -1;
                }
            }
        };
        //方式1
        Arrays.sort(data,comparator);

        System.out.println(Arrays.toString(data));  //升级排序

        //方式2 通过lambda 表达式实现
        Integer[] data2= {19,11,12,18,14,13};

        Arrays.sort(data2,(var1,var2)->{
            if (var1.compareTo(var2)>0){
                return 1;
            }else {
                return -1;
            }
        });

        System.out.println("data2="+Arrays.toString(data2));

    }
}

策略模式的 注意事项和细节

  1. 策略模式的关键是：分析项目中变化部分与不变部分
  2. 策略模式的核心思想是：多用组合/聚合，少用继承；用行为类组合，而不是行为的继承。更有弹性
  3. 体现了”对内聚关闭，对扩展开放“原则，客户端增加了行为不用修改原有代码，只要添加一种策略（或者行为）即可，避免了使用多重转移语句（if…else）
  4. 提供了可以替换继承关系的放啊：策略模式将算法封装在独立的Strategy类中使得你可以独立于其Context改变它，使它易于切换，易于理解，易于扩展
  5. 需要注意的是：每添加一个策略就要增加一个类每当策略过多是会导致类数目庞大
java常用设计模式-策略模式
08-28
策略模式是一种行为型设计模式，它允许您定义一系列算法，将每个算法封装起来，并使它们可以互换使用。这种模式使得算法可以独立于使用它们的客户端而变化。在 Java 中，策略模式通常由一个接口和多个实现该接口的类...
设计模式-策略模式
程序yuan同学
01-25 137
1.介绍： 1)策略模式（Strategy Pattern）中，定义算法族（策略组），分别封装起来，让他们之间可以相互替换，此模式让算法的变化独立于使用算法的客户。比如下文中出现的野鸭是使用算法的客服，实现会飞接口的类组是算法组，在野鸭类中可以使用、替换算法组中某个类。 2）这个算法体现了几个设计原则，第一把变化的代码从不变的代码中分离出来；第二针对接口编程而不是具体类（定义了策略接口）；第三多用组合/聚合，少用继承（客服通过组合方式使用策略） 2.原理类图 3.策略模式的注意事项和细节   策略模式的关
设计模式之策略模式 - 解决多种算法选择的问题
果酱 の 博客
07-11 4817
策略模式是一种行为型设计模式，它定义了一系列的算法，并将每个算法封装在独立的策略类中，使得它们可以相互替换。策略模式使得算法的选择和使用与算法的实现分离开来，客户端可以根据需要选择不同的策略来解决问题，而不需要关心具体的算法实现细节。环境(Context)：环境类持有一个策略类的引用，它在运行时调用策略类的算法。抽象策略(Strategy)：抽象策略类定义了一个公共接口，用于声明所有具体策略类所需实现的方法。具体策略(ConcreteStrategy)：具体策略类实现了抽象策略类定义的算法。
模式识别系列（六）多分类策略
qq_45657975的博客
07-23 1329
目录1.多分类问题引入2.1vN策略3.1v1策略4.Softmax4.1概念与方法4.2softmax梯度传播 1.多分类问题引入   在此篇之前，如果大家还有印象，我们会发现 处理的都是二分类问题，也就是标签y的取值只能是0,1或者-1,1。不论是我们的pla，线性回归，logistic回归，还是svm，最后都是找到一个由权重构成的分类面，它自身的限制导致了这些所有的算法只能处理二分类问题。但是我们在实际运用中，往往处理的不仅仅是“是或不是”的问题，很多时候是“是什么”的问题，那么这就是多分类问题，比如
java策略模式及其优化
qq_36939013的博客
10-19 364
策略模式 将不同的地方剥离出来写成一个接口，可以用来减少冗余代码 接口 public interface MyPredicate<T> { boolean test(T t); } 两个实现类 public class FilterEmployeeByAge implements MyPredicate<Employee> { @Override ...
策略模式
weixin_41249041的博客
05-13 218
工厂+策略模式 策略模式的使用一般不是独立使用的，可能要结合单例、工厂、享元等这些方式一起来实现一段优雅的业务逻辑，一个对象的行为经常要变化，扩展性要求比较高，这种时候可以考虑使用策略模式，来抽象行为， 工厂+策略模式（用lambda来简化代码） 促销业务实现：不同的促销形式 /** * @author jimmy * 策略的函数式接口 */ @FunctionalInterface public interface PromotionStrategy { void do...
Java设计模式-策略模式
12-21
略模式是一种行为设计模式，它使你能在运行时改变对象的行为。在Java中，策略模式主要用来处理同一操作的不同实现，使得系统可以根据不同的条件选择不同的算法或行为。 策略模式的核心结构包括策略接口（Strategy ...
c++设计模式-行为型模式-策略模式
06-19
c++设计模式-行为型模式-策略模式；qt工程；c++简单源码； 策略（Strategy）模式的定义：该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。策略模式属于...
设计模式--策略模式java例子
02-06
策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。在Java中，策略模式通常用于替换硬编码的条件语句，使代码更加灵活、可扩展和易于维护。下面我们将详细探讨策略模式的核心概念、实现方式以及在实际...
设计模式-策略模式（Strategy）
09-20
策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。这种模式允许你使用算法族，而无需在代码中硬编码这些算法。通过将算法封装到具有共同接口的独立对象中，策略模式使得你可以根据需要灵活地切换算法，...
【设计模式】-策略模式
在这个充满危险的乱世之中，只有学会烤鸡才能顽强的活下去。
01-03 308
一、策略模式定义： 策略模式：它定义了算法家族，分别封装起来，让他们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的客户。 二、结构图 三、在什么情况下应当使用策略模式 1.如果在一个系统里面有许多类，他们之间的区别仅在于他们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。比方说商场促销。 2.一个系统需要动态地在集中算法中选择一种，那么这些算法可以包装一个个具体...
25. 策略模式
weixin_34194317的博客
05-15 275
为什么80%的码农都做不了架构师？>>> ...
一文读懂Java中应用最广泛的策略模式
最新发布
liwenxiang629的博客
12-14 898
策略模式是应用最为广泛也是最基础的设计模式。策略模式定义了一系列算法，并将每个算法封装起来，使他们可以相互替换，且算法的变化不会影响到使用算法的客户。需要设计一个接口，为一系列实现类提供统一的方法，多个实现类实现该接口，设计一个类或者抽象类（可有可无，属于辅助类），提供辅助函数。
使用策略模式代替过多的if else
热门推荐
程序员
08-15 1万+
今天闲来突然想起以前面试的一个问题，如果在很多种情况下，比如很多类型分别处理不同的业务逻辑，这些类型以后可能会持续增加到很多，是一直使用if else，有没有更好的解决办法。当时没回答上，现在记录下，学习。用策略模式 策略模式的定义和使用场景 定义：策略模式定义了一系列的算法，并将每一个算法封装起来，而且使他们可以相互替换，让算法独立于使用它的客户而独立变化。 分析下定义，策略模式定义和封装...
策略模式，工作中你用上了吗？
GQ_666的博客
01-11 870
目录 1.策略模式定义： 2.策略模式的使用场景 2.1 逆推法，策略模式被前辈们总结出来，解决的主要问题？ 2.2 面试是实战中的逻辑图： 3.实战demo 3.1策略接口 3.2 A 类型策略具体实现 3.3 B 类型策略具体实现 3.4 默认类型策略具体实现 3.5 不同角色的枚举 3.6 service层 4.策略模式优缺点 4.1优点 4.2缺点 1.策略模式定义： 策略模式定义了接口和不同的实现类，分别封装起来，让它们之间可以相互替换，此模式让算法...
据说是程序员工作中用到的最多的模式：策略模式解析
程序员七哥
06-20 611
这是从零学习设计模式的第一篇文章，也算是入门篇吧。 大家都知道设计模式很重要，掌握设计模式是一个高级开发乃至架构师都必须要具备的技能。 但是不知道有没有这样的感觉，每次看设计模式的概念都差不多能看懂，但是就是不会用，而且不能够识别一些优秀的代码具体是运用了什么设计模式？ 最终的结果就是，慢慢的忘记，脑海中的设计模式只是一个很大很虚的概念。 我目前就属于这种状态，为了能够提高自己的编码设计能力，在工作中设计出有弹性，好维护，能更好的应付业务变化的代码，准备认真学习一边设计模式。 其实大学期间就断断续续看过《H
什么时候应该使用策略模式及策略模式的优缺点
翅膀同学的CSDN Blog
11-07 3759
http://www.cnblogs.com/zhangronghua/archive/2008/07/16/1244207.html 在什么时候应该使用Strategy Pattern呢？毕竟我们学了就是要用的，这里让我们来看一个吕震宇所列的几个情形： 1. 如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。 2. ...
策略模式的优缺点
Leon_Jinhai_Sun的博客
11-07 6033
优点： 1、策略模式符合开闭原则。 2、避免使用多重条件转移语句，如if...else...语句、switch 语句 3、使用策略模式可以提高算法的保密性和安全性。 缺点： 1、客户端必须知道所有的策略，并且自行决定使用哪一个策略类。 2、代码中会产生非常多策略类，增加维护难度。 ...
Objective-C实现iOS策略模式：设计模式实例解析
“iOS App设计模式开发中策略模式的实现示例，通过Objective-C语言描述，适用于iOS应用开发，涉及策略模式、设计模式以及Objective-C编程。” 策略模式（Strategy Pattern）是一种行为设计模式，它使你能在运行时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值