设计模式之策略模式(Strategy)

最新推荐文章于 2025-09-07 23:10:54 发布
原创 最新推荐文章于 2025-09-07 23:10:54 发布 · 1.6w 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#设计模式 #java

本文围绕Java中的策略模式展开。先介绍了comparator和comparable接口中的策略模式应用，接着阐述环境准备过程，包括初始化、尝试变通、换方向及优化等步骤，最后详细讲解策略模式，通过新建接口、改造方法等实现多种比较策略，如猫按身高和体重比较。

设计模式之策略模式

设计模式之策略模式


在jdk1.8之后，为了和之前的接口进行兼容，接口里面必须方法实现，因为要支持lambda表达式。

comparator接口，就是用到了策略模式

在这里插入图片描述

同样，java.lang中的comparable接口，也是策略模式

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

环境准备

初始化

  • 定义一个排序工具（选择排序法），再定义一个其他类，自定义一个int类型的数组，调用sort方法。
package com.cyc.design.strategy;

import java.util.Arrays;

/**
 * @author chenyunchang
 * @version 1.0
 * @date 2021/6h/1 15:05
 * @Description: 主方法
 */
public class Main {
    public static void main(String[] args) {
        int[] a = {9, 2, 3, 5, 7, 1, 4};
        Sorter sorter = new Sorter();
        sorter.sort(a);
        System.out.println(Arrays.toString(a));
    }
}


package com.cyc.design.strategy;

/**
 * @author fei
 * 选择法排序
 */
public class Sorter {

    public void sort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int minPos = i;

            for (int j = i + 1; j < arr.length; j++) {
                minPos = arr[j] < arr[minPos] ? j : minPos;
            }
            swap(arr, i, minPos);
        }
    }

    static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}
  • 输出结果
[1, 2, 3, 4, 5, 7, 9]

Process finished with exit code 0
  • 思考：这里要排序的是int数组，如果要排序double数组，还要再写一遍double类型的排序算法吗？同样的算法实现好多遍？

尝试变通

  • 新建一个类，Cat，有体重，身高属性，里面写一个compareTo方法
package com.cyc.design.strategy;

/**
 * @author chenyunchang
 * @version 1.0
 * @date 2021/6/1 15:36
 */
public class Cat {
    int weight, height;

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

    public int compareTo(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 "Cat{" +
                "weight=" + weight +
                ", height=" + height +
                '}';
    }
}
  • 改造sort方法
package com.cyc.design.strategy;

/**
 * @author fei
 * 选择法排序
 */
public class Sorter {

    public void sort(Cat[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int minPos = i;

            for (int j = i + 1; j < arr.length; j++) {
                minPos = arr[j].compareTo(arr[minPos]) == -1 ? j : minPos;
            }
            swap(arr, i, minPos);
        }
    }

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

改写main方法

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

执行main方法，输出结果

[Cat{weight=1, height=1}, Cat{weight=3, height=3}, Cat{weight=5, height=5}]

现在cat是可以被排序了, 但是如果以后有了dog，rabbit…，依然要重写一个sort。

换个方向

  1. 定义一个接口，Comparable
package com.cyc.design.strategy;

/**
 * @author fei
 */
public interface Comparable {
    int compareTo(Object o);
}
  1. Cat实现Comparable接口

改造Cat里面的compareTo方法

    public int compareTo(Object o) {
        Cat c = (Cat) o;
        if (this.weight < c.weight) {
            return -1;
        } else if (this.weight > c.weight) {
            return 1;
        } else {
            return 0;
        }
    }

compareTo，入参改为Object类型，然后再下面进行cat的强制转换

  1. 新建一个Dog类，实现Comparable方法
package com.cyc.design.strategy;

/**
 * @author chenyunchang
 * @version 1.0
 * @date 2021/6/1 16:10
 */
public class Dog implements Comparable{
    int food;

    @Override
    public int compareTo(Object o) {
        Dog dog = (Dog) o;
        if (this.food < dog.food) {
            return -1;
        } else if (this.food > dog.food){
            return 1;
        }
        return 0;
    }


    public Dog(int food) {
        this.food = food;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "food=" + food +
                '}';
    }
}
  1. 改造sort方法
package com.cyc.design.strategy;

/**
 * @author fei
 * 选择法排序
 */
public class Sorter {

    public void sort(Comparable[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int minPos = i;

            for (int j = i + 1; j < arr.length; j++) {
                minPos = arr[j].compareTo(arr[minPos]) == -1 ? j : minPos;
            }
            swap(arr, i, minPos);
        }
    }

    static void swap(Comparable[] arr, int i, int j) {
        Comparable temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}
  1. main方法
    public static void main(String[] args) {
//        int[] a = {9, 2, 3, 5, 7, 1, 4};
//        Cat[] a = {new Cat(3, 3), new Cat(5, 5), new Cat(1, 1)};
        Dog[] a = {new Dog(3), new Dog(5), new Dog(1)};
        Sorter sorter = new Sorter();
        sorter.sort(a);
        System.out.println(Arrays.toString(a));
    }

查看输出结果

[Cat{weight=1, height=1}, Cat{weight=3, height=3}, Cat{weight=5, height=5}]
[Dog{food=1}, Dog{food=3}, Dog{food=5}]

问题：如果cat的compareTo方法，传入的不是Cat类型的参数，那么此处强制转换便会报错。

优化

利用jdk1.5的新特性，泛型，comparable接口里指定一个泛型的参数

改造的代码如下


public interface Comparable <T>{
    int compareTo(T o);
}



public class Cat implements Comparable<Cat>{
    int weight, height;

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

    @Override
    public int compareTo(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 "Cat{" +
                "weight=" + weight +
                ", height=" + height +
                '}';
    }
}



public class Dog implements Comparable<Dog>{
    int food;

    @Override
    public int compareTo(Dog dog) {
        if (this.food < dog.food) {
            return -1;
        } else if (this.food > dog.food){
            return 1;
        }
        return 0;
    }


    public Dog(int food) {
        this.food = food;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "food=" + food +
                '}';
    }
}

– 可是这种模式依然不够灵活，猫比较大小的策略可能不止这一种，如果比较大小的方式也能灵活配置就好了。

设计模式中，有一种开闭原则，对修改关闭，对扩展开放。

接下来，开始策略模式

策略模式

  1. 新建一个Comparator接口
package com.cyc.design.strategy;

public interface Comparator<T> {
    int compareTo(T o1, T o2);
}
  1. 改造Sorter的sort方法

public class Sorter<T> {

    public void sort(T[] arr, Comparator<T> comparator) {
        for (int i = 0; i < arr.length - 1; i++) {
            int minPos = i;

            for (int j = i + 1; j < arr.length; j++) {
                minPos = comparator.compare(arr[j], arr[minPos]) ==-1 ? j : minPos;
            }
            swap(arr, i, minPos);
        }
    }

    void swap(T[] arr, int i, int j) {
        T temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}
  1. 新建一个DogComparator
public class DogComparator implements Comparator<Dog> {
    @Override
    public int compare(Dog o1, Dog o2) {
        if(o1.food < o2.food) {
            return -1;
        } else if (o1.food > o2.food) {
            return 1;
        } else {
            return 0;
        }
    }
}
  1. main方法
public class Main {
    public static void main(String[] args) {
//        int[] a = {9, 2, 3, 5, 7, 1, 4};
//        Cat[] a = {new Cat(3, 3), new Cat(5, 5), new Cat(1, 1)};
        Dog[] a = {new Dog(3), new Dog(5), new Dog(1)};
        Sorter<Dog> sorter = new Sorter<>();
        sorter.sort(a,new DogComparator());
        System.out.println(Arrays.toString(a));
    }
}
  1. 输出结果
[Dog{food=1}, Dog{food=3}, Dog{food=5}]

此时效果不够明显，当一个类有多中比较方式的时候。即一个类可以有多种比较策略

例如： 猫，根据身高和体重分别比较大小

新建一个猫身高比较器和体重比较器

public class CatHeightComparator implements Comparator<Cat> {
    @Override
    public int compare(Cat o1, Cat o2) {
        if (o1.height > o2.height) {
            return -1;
        } else if (o1.height < o2.height) {
            return 1;
        } else {
            return 0;
        }
    }
}


public class CatHeightComparator implements Comparator<Cat> {
    @Override
    public int compare(Cat o1, Cat o2) {
        if (o1.height > o2.height) {
            return -1;
        } else if (o1.height < o2.height) {
            return 1;
        } else {
            return 0;
        }
    }
}

main方法

public class Main {
    public static void main(String[] args) {
//        int[] a = {9, 2, 3, 5, 7, 1, 4};
        Cat[] a = {new Cat(3, 3), new Cat(5, 5), new Cat(1, 1)};
//        Dog[] a = {new Dog(3), new Dog(5), new Dog(1)};
        Sorter<Cat> sorter = new Sorter<>();
        sorter.sort(a,new CatWeightComparator());
//        sorter.sort(a,new CatHeightComparator());
        System.out.println(Arrays.toString(a));
    }
}

当按照体重比较时，输出结果为

[Cat{weight=1, height=1}, Cat{weight=3, height=3}, Cat{weight=5, height=5}]

当按照身高比较时，输出结果为

[Cat{weight=5, height=5}, Cat{weight=3, height=3}, Cat{weight=1, height=1}]
23种设计模式-策略(Strategy)设计模式
片言可决讼，半纸能缚龙
11-16 1804
软考中级-软件设计师 策略设计模式
设计模式之策略模式
yimeixiaolangzai的博客
08-09 1150
策略模式是一种行为设计模式，它定义了一系列算法，并将每种算法封装在一个独立的类中，使得算法可以在客户端之间相互替换。策略模式使得算法的变化不会影响使用算法的客户端，从而提高了代码的灵活性。首先，我们定义一个接口，该接口定义了一个pay方法，用于处理支付逻辑。策略模式通过将算法封装在独立的策略类中，使得程序可以在不修改客户端代码的情况下动态地切换算法。这种设计模式在提高代码的灵活性和可维护性方面具有显著的优势，适用于多个行为仅在算法上有所不同的场景。
设计模式——策略模式
持之以恒！
02-28 714
1.策略模式 定义一系列算法，把他们独立封装起来，并且这些算法之间可以相互替换。策略模式主要是管理一堆有共性的算法，策略模式让算法独立于使用它的客户而变化，客户端可以根据需要，很快切换这些算法，并且保持可扩展性。 策略模式的本质：分离算法，选择实现。 2.UML类图 策略模式结构中包括三种角色： 策略（Strategy）：策略是一个接口，该接口定义若干个算法标识，即定
设计模式：策略模式（Strategy Pattern）
最新发布
TechNomad的博客
09-07 1173
策略模式是一种行为型设计模式，它定义了一系列算法，把它们一个个封装起来，并且使它们可以相互替换。这样，算法的变化不会影响到使用算法的客户。
策略模式（Strategy）
happylife1527的专栏
09-11 486
http://www.cnblogs.com/justinw/archive/2007/02/06/641414.html 鸭子-策略模式（Strategy） 前言 万事开头难，最近对这句话体会深刻！这篇文章是这个系列正式开始介绍设计模式的第一篇，所以肩负着确定这个系列风格的历史重任，它在我脑袋里默默地酝酿了好多天，却只搜刮出了一点儿不太清晰的轮廓，可是时间不等人，以后再多“迭代”
设计模式之-策略模式
码蚁Q
07-03 1924
策略模式定义了一系列的算法，把它们一个个封装起来，并且使它们可以互相替换。本模式使得算法可独立于使用它的客户端而变化。通俗理解：将一组相似的行为抽象出来，通过统一的接口进行约束，客户端根据实际情况选择使用哪种行为策略。策略模式是行为型设计模式中非常常用的一种，它通过将行为算法独立封装，提升了系统的扩展性和灵活性，尤其适用于行为变动频繁的业务场景。尽管它带来了类的数量增加，但其带来的结构清晰和维护便利往往更值得。
PHP设计模式之 策略模式Strategy详解【对象行为型】
12-18
本文实例讲述了PHP设计模式之 策略模式Strategy。分享给大家供大家参考，具体如下： 1.概述  在软件开发中也常常遇到类似的情况，实现某一个功能有多种算法或者策略，我们可以根据环境或者条件的不同选择不同的算法...
Java设计模式之策略模式（Strategy模式）介绍
09-03
策略模式是一种设计模式，它属于对象行为型模式，主要用于封装一系列相关的算法，使得可以在运行时动态选择不同的算法。在Java中，策略模式通过定义接口或抽象类来规范这些算法的行为，然后通过继承或实现这些接口/...
设计模式-策略模式 Strategy Pattern 详解
03-02
策略模式（Strategy Pattern）是23种设计模式之一，属于行为型模式。该模式定义了一系列算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法的变化独立于使用算法的客户。 在C#中实现策略模式...
Java设计模式-策略模式
Java硬件工程师的博客
07-04 310
1 概述 先看下面的图片，我们去旅游选择出行模式有很多种，可以骑自行车、可以坐汽车、可以坐火车、可以坐飞机。 作为一个程序猿，开发需要选择一款开发工具，当然可以进行代码开发的工具有很多，可以选择Idea进行开发，也可以使用eclipse进行开发，也可以使用其他的一些开发工具。 定义： 该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。策略模式属于对象行为模式，它通过对算法进行封装，把使用算法的责任和算法的实现分割开来，并委派给不同的对象对这些算法进行管
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

意田天

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

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

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

打赏作者

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

抵扣说明：

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

余额充值