设计模式——策略模式

于 2022-11-03 12:38:01 发布
阅读量153 收藏
点赞数
分类专栏： 设计模式 文章标签： 策略模式 设计模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ningxuezhu/article/details/127667887
版权

所有源码的git地址https://gitee.com/0x208_jackson/design-patterns

1、设计模式该怎么用

​ 当我们项目中出现了多个if……else的时候就可以选择使用策略模式，策略模式就是做同一件事件的不同的方法，设计模式说到底就是java多态的灵活运用。设计项目时我们一般要遵循开闭原则，即关闭修改，打开扩展，也就是说尽量别去修改现有的代码，而是对其进行扩展，这就要求我们在设计的时候需要考虑到可以进行灵活的扩展。

2、策略模式-比较动物大小

2.1、根据体重比较

我们现在有一只猫，根据体重比较猫的大小，代码如下：

猫的实体对象

package com.xin.demo.strategy;

import java.io.Serializable;

public class Cat implements Serializable {
    private final int weight;
    private final int height;

    public int compareToHeight(Cat cat) {
        return this.weight - cat.weight;
    }

    public Cat(int weight, int height) {
        this.weight = weight;
        this.height = height;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "weight=" + weight +
                ", height=" + height +
                '}';
    }
}

排序：

package com.xin.demo.strategy;

public class Sort {
    // 此处通过 采用选择排序进行排序
    public static void selectionSort(Cat[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
              // 此处是重点需要注意，注意看调用的方法名
              // 此处需要根据 不同的比较方式去调用不同的方法，也就是会产生多个if……else
              minIndex = arr[j].compareToHeight(arr[minIndex]) < 0 ? j : minIndex;
            }
            swap(arr, i, minIndex);
        }
    }

    public static void swap(Cat[] arr, int i, int j) {
        Cat tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

}

执行：

package com.xin.demo.strategy;

import java.util.Arrays;

public class OperatorMain {
    public static void main(String[] args) {
        Cat[] a = {new Cat(23, 2),
                new Cat(14, 11),
                new Cat(5, 7),
                new Cat(1, 1)};
        Sort.selectionSort(a);
        System.out.println(Arrays.toString(a));
    }
}
2.2、根据身高比较

现在我希望根据猫的身高比较猫的大小，按照常规写法，我们需要在 Cat 对象里面在实现一个方法.

package com.xin.demo.strategy;

import java.io.Serializable;

public class Cat implements Serializable {
    private final int weight;
    private final int height;
  
    public int compareToHeight(Cat cat) {
        return this.weight - cat.weight;
    }

    // 此处为新增加的 根据体重进行比较的方法
    public int compareToWeight(Cat cat) {
        return this.weight - cat.weight;
    }

    public Cat(int weight, int height) {
        this.weight = weight;
        this.height = height;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "weight=" + weight +
                ", height=" + height +
                '}';
    }
}

修改排序的调用方法

package com.xin.demo.strategy;

public class Sort {
    // 此处通过 采用选择排序进行排序
    public static void selectionSort(Cat[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
            // 注意此处改成了 调用体重的方法
            // 此处需要根据 不同的比较方式去调用不同的方法，也就是会产生多个if……else
 							minIndex = arr[j].compareToWeight(arr[minIndex]) < 0 ? j : minIndex;
            }
            swap(arr, i, minIndex);
        }
    }

    public static void swap(Cat[] arr, int i, int j) {
        Cat tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

}
2.3、根据策略模式

​ 以上两种情况我们发现，如果在做同一件猫的大小的比较，根据不同的方式去做的时候我们需要写很多冗余的代码，且不利于扩展，如在增加一种比较方式的时候，我们需要继续进行方法的迭代，且排序方法需要在增加或者重写，此处策略主要针对的是排序部分。

​ 既然是同一件事情，不同的方式去做，那么我们可以定义一个比较器接口，通过不同的实现来完成。

首先定义一个接口：

package com.xin.demo.strategy;

public interface Comparator<T> {

    // 比较器
    int compare(T o1, T o2);
}

对应的实现：

体重：

package com.xin.demo.strategy;

public class CatCompareToHeight implements Comparator<Cat> {
    @Override
    public int compare(Cat o1, Cat o2) {
        return o1.height - o2.height;
    }
}

身高：

package com.xin.demo.strategy;

public class CatCompareToWeight implements Comparator<Cat> {
    @Override
    public int compare(Cat o1, Cat o2) {
        return o1.weight - o2.weight;
    }
}

排序方法：

package com.xin.demo.strategy;

public class StrategySort<T> {
    // 此处通过 采用选择排序进行排序
    public void selectionSort(T[] arr, Comparator<T> comparator) {
        if (arr == null || arr.length < 2) {
            return;
        }
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
              // 重点
                minIndex = comparator.compare(arr[j], arr[minIndex]) < 0 ? j : minIndex;
            }
            swap(arr, i, minIndex);
        }
    }

    public void swap(T[] arr, int i, int j) {
        T tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

}

执行：

package com.xin.demo.strategy;

import java.util.Arrays;

public class OperatorMain {
    public static void main(String[] args) {

        Cat[] cat = {new Cat(3, 4),
                new Cat(14, 11),
                new Cat(5, 17),
                new Cat(1, 2)};
        // 普通写法
        Sort.selectionSort(cat);
        System.out.println(Arrays.toString(cat));

        // 策略模式写法
        StrategySort<Cat> strategySort = new StrategySort<>();
        // 传进去需要比较的对象，以及对应的策略，也就是对应的比较方式
        // 根据身高比较
        strategySort.selectionSort(cat, new CatCompareToHeight());
        System.out.println("根据height排序："+Arrays.toString(cat));

        //根据体重进行比较
        strategySort.selectionSort(cat, new CatCompareToWeight());
        System.out.println("根据weight排序："+Arrays.toString(cat));

    }
}
2.4、可以比较任何动物的大小
package com.xin.demo.strategy;

import java.util.Arrays;

public class OperatorMain {
    public static void main(String[] args) {
        // 现在我们不仅可以比较猫的大小，还可以比较任何一个动物的大小
        // lambda 表达式写法
        StrategySort<Dog> dogStrategySort = new StrategySort<>();
        Dog[] dogs = {new Dog(3, 9),
                new Dog(1, 11),
                new Dog(4, 1),
                new Dog(2, 2)};
        dogStrategySort.selectionSort(dogs, new Comparator<Dog>() {
            @Override
            public int compare(Dog o1, Dog o2) {
                return o1.height - o2.height;
            }
        });
        System.out.println(Arrays.toString(dogs));
    }
}
永远少年1024
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式——策略模式的学习与理解
12-20
什么是策略模式 通俗的来说。策略模式（ Strategy Pattern）就是将算法封装到具有共同接口的独立类中，以独立与客户端，客户端可以灵活的使用或替换算法族里面不同的算法，降低了耦合性。这种类型的设计模式属于行为...
设计模式--策略设计模式
青春年少不知疼的博客
03-27 144
策略设计模式其实就是多态的使用，父类引用指向子类对象。 策略模式的最大特点是使得算法可以在不影响客户端的情况下发生变化，从而改变不同的功能。 策略模式的缺点其实也很明显，在于策略模式把每一种具体的策略都封装成一个实现类，如果策略有很多的话，很显然是实现类就会导致过多，显得臃肿。 案列： /** * @author dengchao * @Description: 策略角色 *...
多态和策略模式
此男子淡漠
07-01 1809
今天我们继续来讲解一下有关于多态和策略模式 多态 说到多态,我们都知道这是java的特性(继承,封装,多态,抽象)之一,但是我们对他了解多少呢? 我们首先了解一下它的概念: 相同类型的变量，调用同一个方法时呈现出多种不同的行为特征，主要是通过继承来实现，将子类对象直接赋给父类引用变量，这样在编译时引用变量类型是父类类型，而运行时类型是子类类型，导致运行时调用该引用变量的方法总会表现子类方法，而调用...
《设计模式(一)之——策略模式》
莫失莫忘的博客
09-13 244
一、前言 利用模式，我们可以让一个解决方案重复使用，而不是重复造轮子 。 —— 克里斯托福 亚历山大 平常我们是代码都复用，设计模式是经验的复用 对于设计模式，网上的博客、论坛上有着大量的相关文章。而且对于我们日常软件开发时,模块设计的使用也尤为重要。在软件开始的学习????之路也就避不开设计模式 这????了 。运用恰到好处时，会感叹一句 真香… 。下面开始介绍设计模式，关于设计模式的基本分类如：行
多态、策略模式和简单工厂模式的理解
奋斗Andy的博客
01-04 3343
最近在看设计模式一本书，发现策略模式和简单工厂模式很像，刚刚开始我还以为是一样的，总感觉没什么区别，后来才看明白，有一点点个人的理解，记录下来，方便下次复习以及理解。 概念理解: 多态：C++的多态性用一句话概括就是,在基类的函数前加上virtual关键字，在派生类中重写该函数，运行时将会根据   对象的实际类型来调用相应的函数。如果对象类型是派生类，就调用派生类的函数；如果对象类型是基
多态和策略模式的爱恨情仇
邓盛余
03-15 1662
最近在研究设计模式，看的书是《head first设计模式》，后续会出一系列设计模式的专题，一方面自己总结，另一方面和大家共同学习。今天看的主要是策略模式，也就是书的开头，给人的感觉策略模式就是多态，想着肯定没这么简单于是搜索了大量资料进行总结。定义：        策略模式：定义了算法族，分别封装，让它们之间可以相互替换，此模式让算法的变化独立于使用算法的客户。        多态：1.继承  ...
设计模式——策略模式 & 单例模式
03-30
NULL 博文链接：https://maidoudao.iteye.com/blog/1329564
研磨设计模式之策略模式
02-27
 接下来想写写另外一个虽然较简单，但是使用很频繁的模式——策略模式策略模式(Strategy)1 场景问题1.1 报价管理向客户报价，对于销售部门的人来讲，这是一个非常重大、非常复杂的问题，对不同的客户要报不同的...
设计模式——开发常用的设计模式梳理
02-24
本文来自51cto，文章主要介绍了策略模式、观察者模式、装饰模式、单例模式以及饿汉模式等的相关内容。泛化=实现>组合>聚合>关联>依赖一个人(Person)可以买车(car)和房子(House)，那么就可以称：Person类依赖于Car类...
浅析Java设计模式【4】——策略.pdf
07-27
浅析Java设计模式【4】——策略.pdf
java设计模式之——策略模式
04-02
NULL 博文链接：https://lvwenwen.iteye.com/blog/1456554
Python设计模式之策略模式实例详解
12-23
本文实例讲述了Python设计模式之策略模式...设计模式——策略模式 策略模式(strategy):它定义了算法家族,分别封装起来,让他们之间可以相互替换,此模式让算法的变化,不会影响到使用算法的客户 ''' #现金收费抽象类 class
浅谈简单工作流设计——责任链模式配合策略与命令模式的实现
03-04
本文以项目中的一个工作流模块，演示责任链模式、策略模式、命令模式的组合实现！最近在做的一个项目，涉及到的是一个流程性质的需求。关于工程机械行业的服务流程：服务任务流程和备件发运流程。项目之初，需求不是...
设计模式浅谈1——策略模式
03-19
NULL 博文链接：https://qiemengdao.iteye.com/blog/752462
从Java多态到策略模式
肤浅失眠中
04-25 1899
先来复习下java多态：java多态指的是父类引用指向子类对象，不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。接下来我们再说下什么叫策略模式：将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。可能说了这么多你还没明白什么事策略模式，接下我们来举个例子 玩过LOL的同学都知道，LOL
设计模式之策略模式（Strategy Pattern），与 java语言的多态有点像（重点学习）
猎人在吃肉
03-24 493
文章目录一、定义与特点1.1、定义1.2、优点：1.3、缺点：二、角色和UML类图2.1、主要角色如下：2.2、UML类图2.3、示例：2.3.1、Strategy2.3.2、ConcreteStrategyA2.3.3、ConcreteStrategyB2.3.4、ConcreteStrategyC2.3.5、Context：上下文的实现类2.3.6、Client三、鸭子项目示例3.1、需求：3...
java基础学习之多态和策略模式
choukao4407的博客
06-25 310
java三大特性:继承、封装、多态. 今天学习一下多态, 多态的三要素: 继承、重写(overWrite区别于overLoad)、父类引用指向子类对象. 多态的基础是继承, 先来复习一下继承. 继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能...
else 策略模式去掉if_设计模式（三）——简单的状态模式代替if-else
最新发布
05-18
在代码开发过程中，我们经常会遇到需要根据不同的条件执行不同的操作的情况。通常的做法是使用if-else语句来实现条件判断。但是，随着代码量的增加，if-else语句也会不断增多，代码变得越来越难以维护和扩展。为了解决这个问题，我们可以使用设计模式来重构代码，使其更加清晰、简洁和易于扩展。 状态模式是一种行为型设计模式，它允许对象在内部状态改变时改变它的行为。状态模式将状态封装成独立的类，并将请求委托给当前的状态对象。当状态发生改变时，更改状态对象以及委托给它的请求处理。 下面我们以一个简单的电梯控制器为例，来演示如何使用状态模式来代替if-else语句。 首先，我们定义一个抽象的状态类： ```python class LiftState: def open(self): pass def close(self): pass def run(self): pass def stop(self): pass ``` 然后，我们定义具体的状态类，分别代表电梯处于打开、关闭、运行和停止状态： ```python class OpenState(LiftState): def open(self): print("电梯门已经打开了，不需要再打开了！") def close(self): print("电梯门关闭...") return CloseState() def run(self): print("电梯还没关门，不能上下楼！") def stop(self): print("电梯门已经打开了，不能停止！") class CloseState(LiftState): def open(self): print("电梯门打开...") return OpenState() def close(self): print("电梯门已经关闭了，不需要再关闭了！") def run(self): print("电梯开始运行...") return RunState() def stop(self): print("电梯已经停止了，不能再停止了！") class RunState(LiftState): def open(self): print("电梯正在运行，不能打开门！") def close(self): print("电梯正在运行，不能关闭门！") def run(self): print("电梯正在运行...") def stop(self): print("电梯停止运行...") return StopState() class StopState(LiftState): def open(self): print("电梯门打开...") return OpenState() def close(self): print("电梯已经停止了，不能关闭门！") def run(self): print("电梯开始运行...") return RunState() def stop(self): print("电梯已经停止了，不需要再停止了！") ``` 最后，我们定义一个电梯控制器类，用于控制电梯的状态： ```python class LiftController: def __init__(self): self.state = StopState() def set_state(self, state): self.state = state def open(self): self.state = self.state.open() def close(self): self.state = self.state.close() def run(self): self.state = self.state.run() def stop(self): self.state = self.state.stop() ``` 现在，我们可以通过调用电梯控制器类的方法来控制电梯的状态，而无需使用if-else语句： ```python lift_controller = LiftController() lift_controller.open() # 电梯门打开... lift_controller.close() # 电梯门关闭... lift_controller.run() # 电梯开始运行... lift_controller.stop() # 电梯停止运行... ``` 通过使用状态模式，我们可以将电梯控制器的不同状态封装成独立的类，使代码更加清晰、简洁和易于扩展。此外，状态模式还可以减少if-else语句的使用，提高代码的可读性和可维护性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值