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

最新推荐文章于 2024-07-06 17:27:32 发布
最新推荐文章于 2024-07-06 17:27:32 发布
阅读量1.6w 收藏
点赞数 1
分类专栏： 设计模式 Java 文章标签： 设计模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A_Java_Dog/article/details/117444265
版权

设计模式之策略模式

设计模式之策略模式


在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}]
意田天
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
设计模式-策略模式
weixin_33645586的博客
12-31 537
《Java设计模式》 前言： 俗话说：条条大路通罗马。在很多情况下，实现某个目标的途径不止一条，例如我们在外出 旅游时可以选择多种不同的出行方式，如骑自行车、坐汽车、坐火车或者坐飞机，可根据实 际情况（目的地、旅游预算、旅游时间等）来选择一种最适合的出行方式。在制订旅行计划 时，如果目的地较远、时间不多，但不差钱，可以选择坐飞机去旅游；如果目的地虽远、但 假期长、且需控制旅游成本时可以选择坐火车或汽车；如果从健康和环保的角度考虑，而且 有足够的毅力，自行车游或者徒步旅游也是个不错的选择，大笑。 在软件开.
PHP设计模式之 策略模式Strategy详解【对象行为型】
12-18
本文实例讲述了PHP设计模式之 策略模式Strategy。分享给大家供大家参考，具体如下： 1.概述  在软件开发中也常常遇到类似的情况，实现某一个功能有多种算法或者策略，我们可以根据环境或者条件的不同选择不同的算法...
设计模式之策略模式
wang0907的博客
01-27 8007
java程序的设计原则 6大原则： 单一职责：一个类和方法只做一件事。 开闭：对修改关闭，对扩展开发。 里氏替换：子类可扩展新方法，但不可修改父类已有方法（父类已提供了具体实现的方法）。 依赖倒置：依赖于抽象，而非具体实现，即面向接口编程（如方法参数，类属性使用接口声明，这样可接收任何子类）。 接口隔离：使用多个隔离的接口定义抽象，降低耦合。 最少知道/迪米特：降低类之间的依赖，聚合，组合等。 1：策略设计模式 策略设计模式一般使用的场景是，多种可互相替代的同类行为，在具体运行过程中根据不同情况，选择其中
设计模式探索：策略模式
最新发布
搬砖的小熊猫的博客
07-06 1152
策略模式（Strategy Pattern）的原始定义是：定义一系列算法，将每一个算法封装起来，并使它们可以相互替换。策略模式让算法可以独立于使用它的客户端而变化。策略模式通过定义一系列算法，将每一个算法封装起来，并使它们可以相互替换，从而让算法可以独立于使用它的客户端而变化。通过使用策略模式，可以提高代码的扩展性、可读性和维护性，同时也可以消除大量的条件语句。
设计模式——策略模式
持之以恒！
02-28 609
1.策略模式 定义一系列算法，把他们独立封装起来，并且这些算法之间可以相互替换。策略模式主要是管理一堆有共性的算法，策略模式让算法独立于使用它的客户而变化，客户端可以根据需要，很快切换这些算法，并且保持可扩展性。 策略模式的本质：分离算法，选择实现。 2.UML类图 策略模式结构中包括三种角色： 策略（Strategy）：策略是一个接口，该接口定义若干个算法标识，即定
策略模式（Strategy）
happylife1527的专栏
09-11 416
http://www.cnblogs.com/justinw/archive/2007/02/06/641414.html 鸭子-策略模式（Strategy） 前言 万事开头难，最近对这句话体会深刻！这篇文章是这个系列正式开始介绍设计模式的第一篇，所以肩负着确定这个系列风格的历史重任，它在我脑袋里默默地酝酿了好多天，却只搜刮出了一点儿不太清晰的轮廓，可是时间不等人，以后再多“迭代”
Java设计模式之策略模式（Strategy模式）介绍
09-03
策略模式是一种设计模式，它属于对象行为型模式，主要用于封装一系列相关的算法，使得可以在运行时动态选择不同的算法。在Java中，策略模式通过定义接口或抽象类来规范这些算法的行为，然后通过继承或实现这些接口/...
C++设计模式之策略模式（Strategy）
12-31
策略模式是一种定义一系列算法的方法，Strategy类层次为Context定义了一系列的可重用的算法或行为， 所有的算法以相同的方式进行调用，减少了算法类之间的耦合 类视图 实现 class Strategy { public: ~Strategy()...
JavaScript设计模式 - 策略模式
11-27 94
策略模式： 定义一系列算法，把他们一个一个封装起来，并且使他们可以相互替换(具有相同的目标和意图)示例 我是 div linear easeIn strongEaseIn strongEaseOut sineaseIn sineaseOut 策略模式指的是定义一些列的算法，把他们一个个封装起来，目的就是将算法的使用与算法的实现分离开来。以策...
Java设计模式-策略模式
Java硬件工程师的博客
07-04 236
1 概述 先看下面的图片，我们去旅游选择出行模式有很多种，可以骑自行车、可以坐汽车、可以坐火车、可以坐飞机。 作为一个程序猿，开发需要选择一款开发工具，当然可以进行代码开发的工具有很多，可以选择Idea进行开发，也可以使用eclipse进行开发，也可以使用其他的一些开发工具。 定义： 该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。策略模式属于对象行为模式，它通过对算法进行封装，把使用算法的责任和算法的实现分割开来，并委派给不同的对象对这些算法进行管
Ruby设计模式编程中Strategy策略模式使用实例分析
Ruby设计模式策略模式的使用实例分析 在Ruby设计模式编程中，Strategy策略模式是常用的设计模式之一，它允许开发者定义一系列的算法，然后将它们一个个地封装起来，使得它们之间可以相互替换。这种模式在Ruby on ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

意田天

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

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

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

打赏作者

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

抵扣说明：

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

余额充值