设计模式 —— 策略模式

最新推荐文章于 2024-04-29 17:29:12 发布
最新推荐文章于 2024-04-29 17:29:12 发布
阅读量482 收藏 8
点赞数 5
分类专栏： 设计模式 文章标签： 设计模式
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/weixin_32265569/article/details/108272514
版权

目录

一、策略模式定义

二、深入浅出拨开策略模式

1、普通整型排序

2、新增自定义类（猫类）并排序

3、实体类实现 Comparable接口，避免Sort相关类越来越多

4、实体类实现带泛型 Comparable接口，避免重写compareTo方法时类型强转

5、通过比较器实现：实体类比较大小的不同策略

一、策略模式定义

策略模式定义了一系列的方法，并将每个方法封装起来，使每个方法可以相互替代，使用方法本身和使用方法的客户端分割开来，相互独立

大白话：同一个类的同一个方法存在不同策略，且策略根据客户端来决定选择哪种策略适合。

二、深入浅出拨开策略模式

这么介绍可能很抽象，还是较难理解策略模式。下面我们将从实际代码一层层拨开策略模式的知识。

1、普通整型排序

定义一个对 整型 int 排序的类及排序方法（为了好理解，以选择排序为例）；应用 T01_Main中 main 方法对其调用排序。

a) 下面是对 整型 int 排序的类及排序方法

public class T01_Sorter {
    public static void sort(int[] arr) {

        for (int time = 0; time < arr.length - 1; time++) {
            int min = time; // 取当前剩下数组第一个元素下标为最小下标
            for (int i = time + 1; i < arr.length; i++) {
                // 找到比当前元素值更小的下标，从当前数组序列头开始一直到结尾
                if (arr[i] < arr[min]) {
                    min = i;
                }
            }

            //System.out.println("minPos: " + minPos);
            // 找到后，将两个值进行交换
            swap(arr, min, time);

            //System.out.println("经过第" + i + "次循环之后，数组的内容：");
        }

    }

    private static void swap(int[] arr, int i, int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

b) 下面是应用 T01_Main中 main 方法对其调用排序

public class T01_Main {
    public static void main(String[] args) {
        int[] a = {9,2,3,5,7,1,4};
        T01_Sorter sorter = new T01_Sorter();
        sorter.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

这似乎世界很友好，也能解决当前问题。现在来了个新需求：新增猫类，并需要对其进行排序。于是我们继续分析

2、新增自定义类（猫类）并排序

接到了新需求：新增猫类，并需要对其进行排序。首先，我们先定义一个 Bean 类 猫类 Cat。

public class T02_Cat {
    int weight, height;

    public T02_Cat(int weight, int height) {
        this.weight = weight;
        this.height = height;
    }
    // 定义猫的比较方法
    public int compareTo(T02_Cat c) {
        if (this.weight < c.weight) return -1;
        else if (this.weight > c.weight) return 1;
        else return  0;
    }

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

再编写一个对猫进行排序的类，因为猫的排序方式是按照身高或体重来排序的，不能复用之前的整型的排序方式

public class T02_Sorter {
    public static void sort(T02_Cat[] arr) {

        for (int time = 0; time < arr.length - 1; time++) {
            int min = time; // 取当前剩下数组第一个元素下标为最小下标
            for (int i = time + 1; i < arr.length; i++) {
                // 找到比当前元素值更小的下标，从当前数组序列头开始一直到结尾
                min = arr[i].compareTo(arr[min]) == -1 ? i : min;
            }

            //System.out.println("minPos: " + minPos);
            // 找到后，将两个值进行交换
            swap(arr, min, time);

            //System.out.println("经过第" + i + "次循环之后，数组的内容：");
        }

    }

    private static void swap(T02_Cat[] arr, int i, int j){
        T02_Cat temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

再创建应用类，对猫进行排序

public class T02_Main {
    public static void main(String[] args) {
        T02_Cat[] a = {new T02_Cat(3,3), new T02_Cat(5,5), new T02_Cat(1,1)};
        T02_Sorter sorter = new T02_Sorter();
        sorter.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

这似乎也能解决需求新增类实体并排序问题，但仔细观察我们发现，如果此时又来一个新的需求：新增狗类并排序。如果按照上述思路继续，我们又得增加狗的Bean类、增加狗的排序类。类越来越多，后期维护起来麻烦。

既然意识到此问题，我们应该怎样解决问题呢？实体Bean类、及对应的排序类是一一对应关系，将比较大小的方式统一写在实体Bean类就可以解决类越来越多的问题，是不错的解决方案。

3、实体类实现 Comparable接口，避免Sort相关类越来越多

为了统一实体类的比较大小的方式，实体类需要实现 Comparable 接口，重写 compareTo方法，这样的好写，实体类的比较方法都是统一的，且大家都需要重写 compareTo 方法。

public interface T03_Comparable {
    public int compareTo(Object a);
}

接下来在定义实体Bean 类时，使用 implements 关键字来实现 Comarable接口

public class T03_Cat implements T03_Comparable {
    int weight, height;

    public T03_Cat(int weight, int height) {
        this.weight = weight;
        this.height = height;
    }
    // 定义猫的比较方法
    @Override
    public int compareTo(Object c) {
        T03_Cat cat = (T03_Cat)c;
        if (this.weight < cat.weight) return -1;
        else if (this.weight > cat.weight) return 1;
        else return  0;
    }

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

排序类 Sorter 不再是对Bean 类进行排序了，而是对接口进行排序。具体比较大小的规则在对应的实体类内部实现，既后续只需要扩展新增对应的实体类（要求实现 implement Compare接口）即可。

public class T03_Sorter {
    public static void sort(T03_Comparable[] arr) {

        for (int time = 0; time < arr.length - 1; time++) {
            int min = time; // 取当前剩下数组第一个元素下标为最小下标
            for (int i = time + 1; i < arr.length; i++) {
                // 找到比当前元素值更小的下标，从当前数组序列头开始一直到结尾
                min = arr[i].compareTo(arr[min]) == -1 ? i : min;
            }

            //System.out.println("minPos: " + minPos);
            // 找到后，将两个值进行交换
            swap(arr, min, time);

            //System.out.println("经过第" + i + "次循环之后，数组的内容：");
        }

    }

    private static void swap(T03_Comparable[] arr, int i, int j){
        T03_Comparable temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

应用类对实体类对象进行排序调用保持不变

public class T03_Main {
    public static void main(String[] args) {
        T03_Cat[] a = {
                new T03_Cat(3,3),
                new T03_Cat(5,5),
                new T03_Cat(1,1)
        };
        T03_Sorter sorter = new T03_Sorter();
        sorter.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

至此： 实体类通过实现 Compare接口，重写 compareTo比较大小方法；比较类 Sorter只需要对接口进行排序即可，算是解决Sorter不再随着实现类新增而新增问题。

但是，上述这种方式不太方便，每次在实体类重定 compareTo 比较大小方法，都需要进行类型强转。为此，可以引用泛型来避免类型强转问题。补充说明一下：泛型是JavaSE5 引入的一个新概念。

4、实体类实现带泛型 Comparable接口，避免重写compareTo方法时类型强转

第三个版本使用Object，实现类在重写 compareTo方法需要进行类型强转，非常不便，可以使用泛型解决

补充说明：泛型是指在接口中，不确定实现此接口的类型是什么，先由泛型T 代替，在实现类中需要指定泛型类型

// 第三个版本使用Object，实现类需要进行强转；非常不便，可以使用泛型
public interface T04_Comparable<T> {
    public int compareTo(T a);
}

实体类实现 Comparable 接口，同时指定泛型类型

// 实体类实现Comparable 时指定泛型类型
public class T04_Cat implements T04_Comparable<T04_Cat> {
    int weight, height;

    public T04_Cat(int weight, int height) {
        this.weight = weight;
        this.height = height;
    }
    // 定义猫的比较方法
    @Override
    public int compareTo(T04_Cat cat) {
        if (this.weight < cat.weight) return -1;
        else if (this.weight > cat.weight) return 1;
        else return  0;
    }

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

Sorter 类排序还是一样对 Compareable排序，与第三个版本保持不变

public class T04_Sorter {
    public static void sort(T04_Comparable[] arr) {

        for (int time = 0; time < arr.length - 1; time++) {
            int min = time; // 取当前剩下数组第一个元素下标为最小下标
            for (int i = time + 1; i < arr.length; i++) {
                // 找到比当前元素值更小的下标，从当前数组序列头开始一直到结尾
                min = arr[i].compareTo(arr[min]) == -1 ? i : min;
            }

            //System.out.println("minPos: " + minPos);
            // 找到后，将两个值进行交换
            swap(arr, min, time);

            //System.out.println("经过第" + i + "次循环之后，数组的内容：");
        }

    }

    private static void swap(T04_Comparable[] arr, int i, int j){
        T04_Comparable temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

应用类与第三个版本应用类保持不变

public class T04_Main {
    public static void main(String[] args) {
        T04_Cat[] a = {
                new T04_Cat(3,3),
                new T04_Cat(5,5),
                new T04_Cat(1,1)
        };
        T04_Sorter sorter = new T04_Sorter();
        sorter.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

这似乎能满足大部分场景，答案是：可以！但到了大型后台业务系统中，就可能水土不服了。为什么这么说呢？

我们还是接着前面猫的比较大小的场景，在业务系统中可能需要按照体重比较大小，也有可能按照身高比较大小，即同一个实体类在不同的业务情况下比较大小的方式不一样。按照上述方式依然无法解决此问题（只能解决一种比较大小的方式），难道就没有办法解决了么？答案是：有的！

终于，引入了正题，前面都是铺垫，是为了更好的理解策略模式。

5、通过比较器实现：实体类比较大小的不同策略

先定认猫类，这里猫类不再实现 Comparable 接口，因此该方式只能实现一种比较大小的策略，如下：

public class T05_Cat {
    public int weight, height;

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

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

猫类比较大小的不同策略，都是compare 方法，为此先定义一个接口比较器 T05_Comparator<T>

，后续按体重比较策略类、按身高比较策略类都实现 T05_Comparator<T> 接口即可

@FunctionalInterface  // 如果确认只有这一个方法，不编写@FunctionalInterface 也是可以的
public interface T05_Comparator<T> {
    int compare(T o1, T o2);
}

再定义身高大小比较器、体重大小比较器 

// 按身高大小的比较器
public class T05_CatHeightComparator implements T05_Comparator<T05_Cat> {

    @Override
    public int compare(T05_Cat o1, T05_Cat o2) {
        if (o1.height > o2.height) return -1;
        else if (o1.height < o2.height) return 1;
        else return 0;
    }
}
// 按体重大小的比较器
public class T05_CatWeightComparator implements T05_Comparator<T05_Cat> {

    @Override
    public int compare(T05_Cat o1, T05_Cat o2) {
        if (o1.weight < o2.weight) return -1;
        else if (o1.weight > o2.weight) return 1;
        else return 0;
    }
}

再定义排序类，将比较器作为参数传入，按照比较器策略来进行大小比较

// 排序类中，将比较器作为参数传入，按照比较器策略来进行大小比较
public class T05_Sorter<T> {
    public void sort(T[] arr, T05_Comparator comparator) {

        for (int time = 0; time < arr.length - 1; time++) {
            int min = time; // 取当前剩下数组第一个元素下标为最小下标
            for (int i = time + 1; i < arr.length; i++) {
                // 找到比当前元素值更小的下标，从当前数组序列头开始一直到结尾
                min = comparator.compare(arr[i], arr[min]) == -1 ? i : min;
            }

            //System.out.println("minPos: " + minPos);
            // 找到后，将两个值进行交换
            swap(arr, min, time);

            //System.out.println("经过第" + i + "次循环之后，数组的内容：");
        }
    }

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

最后，通过应用类来选择不同的比较策略，按需所取

public class T05_Main {
    public static void main(String[] args) {
        T05_Cat[] a = {
                new T05_Cat(3,3),
                new T05_Cat(5,5),
                new T05_Cat(1,1)
        };
        T05_Sorter<T05_Cat> sorter = new T05_Sorter<T05_Cat>();
        //sorter.sort(a, new T05_CatWeightComparator());
        // 采用策略模型：
        //sorter.sort(a, new T05_CatHeightComparator());

        // 写法上，可以采用lambda 表达式进行
        sorter.sort(a, (o1, o2) -> {
            T05_Cat cat1 = (T05_Cat)o1;
            T05_Cat cat2 = (T05_Cat)o2;

            if (cat1.weight < cat2.weight) return -1;
            else if (cat1.weight > cat2.weight) return 1;
            else return 0;
        });

        // 如果一个策略每次调用，都需要 new，因此应该把 DefaultStrategy -> Singleton
        // 通过配置文件加载策略类名，可以动态调整：对修改关闭、对扩展开放（Extensibility Scalability）
        String goodStrategyClassName = "";//PrppertyMgr.get("goodWay");
        try {
            //T05_CatHeightComparator goodStrategy = (T05_CatHeightComparator)Class.forName(goodStrategyClassName).newInstance();
            T05_CatHeightComparator goodStrategy = (T05_CatHeightComparator)Class.forName(goodStrategyClassName).getDeclaredConstructor().newInstance();
            sorter.sort(a, goodStrategy);
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

        // 还可以通过加载类名

        System.out.println(Arrays.toString(a));
    }
}

小总结：

核心点，将策略封装成一个接口，然后可以通过实现策略接口方式实现各式各样的不同策略；应用类调用时按需传入不同的策略即可，或者使用匿名内部类的方式实现接口方法

 

文章最后，给大家推荐一些受欢迎的技术博客链接：

  1. JAVA相关的深度技术博客链接
  2. Flink 相关技术博客链接
  3. Spark 核心技术链接
  4. 设计模式 —— 深度技术博客链接
  5. 机器学习 —— 深度技术博客链接
  6. Hadoop相关技术博客链接
  7. 超全干货--Flink思维导图，花了3周左右编写、校对
  8. 深入JAVA 的JVM核心原理解决线上各种故障【附案例】
  9. 请谈谈你对volatile的理解？--最近小李子与面试官的一场“硬核较量”
  10. 聊聊RPC通信，经常被问到的一道面试题。源码+笔记，包懂
  11. 深入聊聊Java 垃圾回收机制【附原理图及调优方法】

欢迎扫描下方的二维码或 搜索 公众号“大数据高级架构师”，我们会有更多、且及时的资料推送给您，欢迎多多交流！

                                           

       

 

不埋雷的探长
关注
  • 5
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Qt中使用Font Awesome图标字体库
草上爬的博客
03-02 1万+
Font Awesome号称是为Bootstrap设计的完美图标字体，经常出现在各类网页中，非常流行。 官网: https://fontawesome.com/ 中文网: http://www.fontawesome.com.cn/ GitHub: https://github.com/FortAwesome/Font-Awesome 1. 首先我们从官网或者github上下载到最新的源码 建议从github上下载，github上已经是更新6.1了，官网上还是3.2.1 2. 在解压目录中找到 webfon
设计模式之策略模式(实战+大白话)
qq_37805943的博客
07-06 251
策略模式属于对象的行为模式。其用意是针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。 目录 概念以及核心图解，优缺点 策略模式在项目中实际应用场景 结语 正文开始 概念以及核心图解, 优缺点。 review之前写的代码, 发现两大问题，分别举出反例 第一：代码中if-else使用及其频繁。(图一) 第二：整体的代码结构十分混乱，毫无美感可言。 (后期会讲述领域驱动设计DDD，一个程序员不会DDD，基本可
Lambda表达式+策略模式+泛型
weixin_44906271的博客
04-26 997
目录引出问题抛出问题一：方式一：抛出问题二：方式二：抛出问题三：方式三：方式四：Lambda表达式语法Lambda只能用在函数式接口JAVA中四个内置函数式接口 引出问题 创建了一个List集合，通过对这个集合的操作，抛出问题，并且利用Lambda表达式解决问题。 public class Test { public static void main(String[] args) { ...
设计模式 -- 策略模式（Strategy Pattern）
魔法师之家
03-22 1460
策略模式定义了一系列的算法，并将每一个算法封装起来，使他们可以相互替换。 策略模式多用在算法决策系统中，外部用户只需要决定用哪个算法即可。 应用场景 针对同一类型的问题有多种处理方式，仅仅是具体的行为有差别时。 需要安全的封装多种同一类型的操作时。 出现同一抽象类的多个子类，而又需要使用if-else来选择子类时。 当存在的策略很多时，客户端管理所有策略算法将变得很复杂，如果在环境类中使用策略工厂模式来管理这些策略类将大大减少客户端的工作复杂度。
设计模式--策略模式（存在多种实现方式）
gs344937933的专栏
04-29 2213
策略模式 定义：定义了算法家族，分别封装起来，让它们之间可以相互替换，此模式让算法的变化不会影响到使用算法的用户。 生活举例，常见的促销活动，用户可以选择不同的促销 代码中，如果有大量的 if...else... 的语句，可以通过 策略模式 消除掉。 类型：行为型 适用场景：（1）系统又很多类，而他们的区别仅仅在于他们的行为不同，（2）一个系统需要动态地在几种算法中选择一种， 优点：...
策略模式
xiaoguobaf的博客
09-17 454
1、定义 策略模式定义了算法族，分别封装起来，让他们之间可以相互替代，此模式的变化独立于使用算法的客户 上述中的算法即行为、方法，策略模式通俗点说，解决一个问题有多种方法，程序在运行时会自己去选择执行什么方法策略模式的角色： 抽象策略角色（Strategy）：策略类，通常由一个接口或者抽象类实现 具体策略角色（ConcreteStrategy)：包装了相关的算法和行为 环境角色(Contex
设计模式——策略模式
无忧少年的博客
08-25 213
设计模式——策略模式 @author lisiwen @createTime 2019/7/16 ​ 策略模式: 它定义了算法家族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的客户端 策略模式简单的说就是用户在客户端自己选择对应的策略也就是选择算法。 策略模式结构图： 将我在简单工厂模式中的计算器的算法用策略模式实现的代码如下: // 运算类 publi...
设计模式——策略模式的学习与理解
12-20
策略模式是一种行为设计模式，它的主要目的是将不同的算法或行为封装在独立的可互换的类中，使得客户端代码能够灵活地选择并使用这些算法，而无需关心它们的具体实现。这种模式遵循了几条重要的设计原则： 1. **...
设计模式——策略模式 & 单例模式
03-30
策略模式和单例模式是软件设计中两种非常重要的设计模式，它们在实际开发中有着广泛的应用。在这篇文章中，我们将深入探讨这两种模式的核心概念、实现方式以及如何在实际项目中运用。 策略模式是一种行为设计模式，...
JavaScript 设计模式——策略模式
Starry_Firmament的博客
12-29 2131
是一种行为设计模式，能让我们定义一系列算法，并将每种算法分别放入独立的类中，以使算法的对象能够相互替换。
策略模式：定义与实现
最新发布
Shooter_whole的博客
04-29 405
策略模式（Strategy Pattern）属于对象的行为模式，其定义了算法族，分别封装起来，让它们之间可以互相转换，此模式让算法的变化独立于使用算法的用户。
应用泛型的策略模式
软件的信雅达
04-16 4894
应用泛型的策略模式作者：Dr. Heinz M. Kabutz   摘要策略模式相当的简单。通过使用这个模式，我们可以把一些内聚的状态转化为一些外在的状态，这样可以实现共享策略对象。当每一个策略对象为了实现它的功能而需要不同批次的信息的时候，策略模式将变得相当的灵活。在这篇文章里，我们将看到我们如何使用Java5的泛型把正确的上下文子类型传递到每一个策略对象中。 欢
java接口应用策略模式_java设计模式-策略模式（包含Comparable接口和泛型的使用）...
weixin_36206388的博客
03-02 330
1.为什么需要Comparable接口举一个简单的例子，对int数组元素进行选择排序。程序如下:package com.methon.comparable;public class Sorter {public static void sort(int[] arr) {for (int i = 0; i < arr.length; i++) {int minPos = i;for (int ...
VB.NET接口泛型+策略模式+单例模式
李黎敏 ——为优秀j2ee架构师而努力
01-05 2622
在程序中的数据访问层中，经常会遇到返回实体类的情况，而不同的实体类大多具有相似的代码，情况也大致相同：有的是返回实体类的一条记录，有的是返回实体类的集合。这样如果仅按照最简单的写法的话，程序中会出现许多相似的代码，给人一种不舒服的感觉，如果发现一个程序中有许多重复类似的代码，那么就是程序中的坏味道，我们就应该想办法，对这些代码的实质进行抽象，进行优化，那么接下来要总结的接口泛型就是这么一个例子，另
设计模式 —— 装饰者模式
认知 行动 坚持
09-02 6343
目录 一、星巴克咖啡订单项目需求 二、方案1-解决星巴克咖啡订单项目（较差） 三、方案2-解决星巴克咖啡订单（好点） 四、装饰者模式定义 4.1 装饰者模式原理 4.2 装饰者模式解决星巴克咖啡订单 五、装饰者模式在 JDK 应用的源码分析 装饰者模式定义： 动态给一个对象添加一些额外的职责，就像在墙上刷油漆，使用Decorator 模式相比用生成子类方式达到功能的扩充显得更为灵活。 初计初衷： 通常可以使用继承来实现功能的扩展，如果这些需要扩展的功能的种类很繁多，那么势必...
设计模式 —— 概述 及 七大设计原则【含示例&小总结】
认知 行动 坚持
08-30 972
一、设计模式的重要性 软件工程中，设计模式（design pattern）是对软件设计中普遍存在（反复出现）的各种问题，所提出的解决方案。这个术语是由 埃里希.伽玛（Erich Gamma）等人在1990年代从建筑设计领域引入到计算机科学的 大厦 VS 简易房 拿实际工作经历来说，当一个项目开发完后，如果客户提出新增功能，怎么办？(可扩展性，使用设计模式，软件具有很好的扩展性) 如果项目开发完后，原来程序员离职，你接手维护项目怎么办？（维护性 [可读性、规范性]） 目前程序员门槛越来越高，一线IT
设计模式 —— 深度技术博客链接
认知 行动 坚持
09-05 900
设计模式 —— 概述 及 七大设计原则【含示例&小总结】 设计模式 —— UML 类图 设计模式之 —— 单例模式​​​​​​​ 设计模式之 —— 策略模式 设计模式 —— 工厂模式（简单工厂、工厂方法、抽象工厂） 设计模式 —— 装饰者模式 设计模式 —— 代理模式 设计模式 —— 观察者模式 文章最后，给大家推荐一些受欢迎的技术博客链接： JAVA相关的深度技术博客链接 Flinak 相关技术博客链接 ...
设计模式在Android开发中的应用——策略模式
"Strategy(策略模式) - 从设计模式开启Android开发" 设计模式是软件工程中的一种最佳实践，它们代表了在特定情况下解决问题的通用解决方案。这些模式被广泛应用于各种编程语言，包括Android开发。策略模式是行为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

不埋雷的探长

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值