设计模式——策略模式

于 2022-11-03 12:38:01 发布
阅读量165 收藏
点赞数
分类专栏： 设计模式 文章标签： 策略模式 设计模式 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
策略模式是一种行为设计模式，它的主要目的是将不同的算法或行为封装在独立的可互换的类中，使得客户端代码能够灵活地选择并使用这些算法，而无需关心它们的具体实现。这种模式遵循了几条重要的设计原则： 1. **...
设计模式之策略模式（Strategy Pattern），与 java语言的多态有点像（重点学习）
猎人在吃肉
03-24 650
文章目录一、定义与特点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...
多态和策略模式
此男子淡漠
07-01 1943
今天我们继续来讲解一下有关于多态和策略模式 多态 说到多态,我们都知道这是java的特性(继承,封装,多态,抽象)之一,但是我们对他了解多少呢? 我们首先了解一下它的概念: 相同类型的变量，调用同一个方法时呈现出多种不同的行为特征，主要是通过继承来实现，将子类对象直接赋给父类引用变量，这样在编译时引用变量类型是父类类型，而运行时类型是子类类型，导致运行时调用该引用变量的方法总会表现子类方法，而调用...
java基础学习之多态和策略模式
choukao4407的博客
06-25 342
java三大特性:继承、封装、多态. 今天学习一下多态, 多态的三要素: 继承、重写(overWrite区别于overLoad)、父类引用指向子类对象. 多态的基础是继承, 先来复习一下继承. 继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能...
设计模式--策略设计模式
青春年少不知疼的博客
03-27 160
策略设计模式其实就是多态的使用，父类引用指向子类对象。 策略模式的最大特点是使得算法可以在不影响客户端的情况下发生变化，从而改变不同的功能。 策略模式的缺点其实也很明显，在于策略模式把每一种具体的策略都封装成一个实现类，如果策略有很多的话，很显然是实现类就会导致过多，显得臃肿。 案列： /** * @author dengchao * @Description: 策略角色 *...
《设计模式(一)之——策略模式》
莫失莫忘的博客
09-13 265
一、前言 利用模式，我们可以让一个解决方案重复使用，而不是重复造轮子 。 —— 克里斯托福 亚历山大 平常我们是代码都复用，设计模式是经验的复用 对于设计模式，网上的博客、论坛上有着大量的相关文章。而且对于我们日常软件开发时,模块设计的使用也尤为重要。在软件开始的学习????之路也就避不开设计模式 这????了 。运用恰到好处时，会感叹一句 真香… 。下面开始介绍设计模式，关于设计模式的基本分类如：行
Java设计模式——策略模式
涛涛的个人博客
10-29 9万+
策略模式 1.策略模式简介 策略模式：策略模式是一种行为型模式，它将对象和行为分开，将行为定义为 一个行为接口 和 具体行为的实现。策略模式最大的特点是行为的变化，行为之间可以相互替换。每个if判断都可以理解为就是一个策略。本模式使得算法可独立于使用它的用户而变化 2.模式结构 策略模式包含如下角色： Strategy: 抽象策略类：策略是一个接口，该接口定义若干个算法标识，即定义了若干个抽象方法（如下图的algorithm()） Context: 环境类 /上下文类： 上下文是依赖于接口的类（
设计模式——策略模式 & 单例模式
03-30
策略模式和单例模式是软件设计中两种非常重要的设计模式，它们在实际开发中有着广泛的应用。在这篇文章中，我们将深入探讨这两种模式的核心概念、实现方式以及如何在实际项目中运用。 策略模式是一种行为设计模式，...
研磨设计模式之策略模式
02-27
 接下来想写写另外一个虽然较简单，但是使用很频繁的模式——策略模式策略模式(Strategy)1 场景问题1.1 报价管理向客户报价，对于销售部门的人来讲，这是一个非常重大、非常复杂的问题，对不同的客户要报不同的...
设计模式——约会版
08-06
在《设计模式——约会版》这一独特视角下探讨的设计模式，并非我们传统意义上的面向对象设计模式（如工厂模式、单例模式等），而是通过模拟约会场景，将抽象的设计原则与实际生活中的互动策略相结合，以此来形象地...
分布式系统设计模式——ppt模式
11-02
分布式系统设计模式是指在分布式系统中，为了解决如何划分服务、如何部署服务以及如何组织服务间通信等问题而采用的一些通用方案和策略。这些模式能够在不同的分布式环境和应用场景中应用，以期达到系统设计的最优解...
浅析Java设计模式【4】——策略.pdf
07-27
策略模式是一种行为型设计模式，它定义了一系列算法，并将每一个算法封装起来，使它们可以互相替换。策略模式让算法独立于使用它的客户而变化。 #### 1.2 使用场景 策略模式适用于以下几种情况： - 多个类只有在...
多态、策略模式和简单工厂模式的理解
奋斗Andy的博客
01-04 3392
最近在看设计模式一本书，发现策略模式和简单工厂模式很像，刚刚开始我还以为是一样的，总感觉没什么区别，后来才看明白，有一点点个人的理解，记录下来，方便下次复习以及理解。 概念理解: 多态：C++的多态性用一句话概括就是,在基类的函数前加上virtual关键字，在派生类中重写该函数，运行时将会根据   对象的实际类型来调用相应的函数。如果对象类型是派生类，就调用派生类的函数；如果对象类型是基
多态和策略模式的爱恨情仇
邓盛余
03-15 1674
最近在研究设计模式，看的书是《head first设计模式》，后续会出一系列设计模式的专题，一方面自己总结，另一方面和大家共同学习。今天看的主要是策略模式，也就是书的开头，给人的感觉策略模式就是多态，想着肯定没这么简单于是搜索了大量资料进行总结。定义：        策略模式：定义了算法族，分别封装，让它们之间可以相互替换，此模式让算法的变化独立于使用算法的客户。        多态：1.继承  ...
从Java多态到策略模式
肤浅失眠中
04-25 1909
先来复习下java多态：java多态指的是父类引用指向子类对象，不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。接下来我们再说下什么叫策略模式：将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。可能说了这么多你还没明白什么事策略模式，接下我们来举个例子 玩过LOL的同学都知道，LOL
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值