java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > Java设计模式之策略模式

Java设计模式之java策略模式详解

作者：大忽悠爱忽悠

这篇文章主要介绍了Java经典设计模式之策略模式,简单说明了策略模式的概念、原理并结合实例形式分析了java策略模式的具有用法与相关注意事项,需要的朋友可以参考下

为什么使用策略模式?

实现某一个功能有多条途径，每一条途径对应一种算法，此时我们可以使用一种设计模式来实现灵活地选择解决途径，也能够方便地增加新的解决途径。

策略模式包含角色

策略模式的类图

在这里插入图片描述

策略模式需要一个策略接口，不同的策略实现不同的实现类，在具体业务环境中仅持有该策略接口，根据不同的场景使用不同的实现类即可。

面向接口编程，而不是面向实现。

排序案例

对数组进行排序的算法有很多，但是不同的算法在不同的场景下可以发挥更大的效率，例如数据量很大的时候，我们可以使用快速排序，数据量小的时候就可以采用插入排序

在这里插入图片描述

抽象策略类

//抽象策略类
public  interface Strategy
{
    public void sort();
}

具体策略类

public class QuickSort implements Strategy
{
    @Override
    public void sort() {
        System.out.println("快速排序");
    }
}

public class InsertSort implements Strategy
{
    @Override
    public void sort() {
        System.out.println("插入排序");
    }
}

public class BubbleSort implements Strategy
{
    @Override
    public void sort() {
        System.out.println("冒泡排序");
    }
}

环境类

public class Context
{
    private  Strategy strategy;
    public void sort(int[] arr,Strategy strategy)
    {
        this.strategy=strategy;
        doSort();
    }
    private void doSort()
    {
        strategy.sort();
    }
}

测试类

public class Client
{
    public static void main(String[] args) {
        int[] arr={1,1,1,1,1,1,1,1,1,1};
        int[] arr1={1,1,1,1,1,1};
        int[] arr2={1,1,1};
        Context context=new Context();
        context.sort(arr,new QuickSort());
        context.sort(arr1,new InsertSort());
        context.sort(arr2,new BubbleSort());
    }
}

在这里插入图片描述

策略模式的优点

策略模式的缺点

适用场景

源码分析策略模式的典型应用

Java Comparator 中的策略模式

java.util.Comparator 接口是比较器接口，可以通过 Collections.sort(List,Comparator) 和 Arrays.sort(Object[],Comparator) 对集合和数据进行排序，下面为示例程序

一个学生类，有两个属性 id 和 name

@Data
@AllArgsConstructor
public class Student {
    private Integer id;
    private String name;
    @Override
    public String toString() {
        return "{id=" + id + ", name='" + name + "'}";
    }
}

实现两个比较器，比较器实现了 Comparator 接口，一个升序，一个降序

// 降序
public class DescSortor implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o2.getId() - o1.getId();
    }
}
// 升序
public class AscSortor implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.getId() - o2.getId();
    }
}

通过 Arrays.sort() 对数组进行排序

public class Test1 {
    public static void main(String[] args) {
        Student[] students = {
                new Student(3, "张三"),
                new Student(1, "李四"),
                new Student(4, "王五"),
                new Student(2, "赵六")
        };
        toString(students, "排序前");
        Arrays.sort(students, new AscSortor());
        toString(students, "升序后");
        Arrays.sort(students, new DescSortor());
        toString(students, "降序后");
    }
    public static void toString(Student[] students, String desc){
        for (int i = 0; i < students.length; i++) {
            System.out.print(desc + ": " +students[i].toString() + ", ");
        }
        System.out.println();
    }
}

在这里插入图片描述

通过 Collections.sort() 对集合List进行排序

public class Client
{
    public static void main(String[] args) {
        List<Stu> students = Arrays.asList(
                new Stu(3, "张三"),
                new Stu(1, "李四"),
                new Stu(4, "王五"),
                new Stu(2, "赵六")
        );
        toString(students, "排序前");
        Collections.sort(students, new AscSortor());
        toString(students, "升序后");
        Collections.sort(students, new DescSortor());
        toString(students, "降序后");
    }
    public static void toString(List<Stu> students, String desc){
        for (Stu student : students) {
            System.out.print(desc + ": " + student.toString() + ", ");
        }
        System.out.println();
    }
}

在这里插入图片描述

我们向 Collections.sort() 和 Arrays.sort() 分别传入不同的比较器即可实现不同的排序效果（升序或降序）

这里 Comparator 接口充当了抽象策略角色，两个比较器 DescSortor 和 AscSortor 则充当了具体策略角色，Collections 和 Arrays 则是环境角色

参考文章

策略模式

总结

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注脚本之家的更多内容！

您可能感兴趣的文章:
阅读全文