设计模式 -（2）策略模式（strategy pattern）

最新推荐文章于 2025-11-24 14:10:54 发布

原创最新推荐文章于 2025-11-24 14:10:54 发布 · 208 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#设计模式 #策略模式 #java

设计模式专栏收录该内容

9 篇文章

订阅专栏

本文探讨策略模式在编程中的应用，如何根据需求切换员工信息排序策略，如按工号或年龄。通过Comparator接口实现不同场景下的比较逻辑，演示了如何在Employee类中使用策略模式和JDK排序工具。

设计模式 -（2）策略模式（strategy pattern）

生活中有这样一些场景，例如在网购时，对于同一件商品，普通买家需要全额购买，而会员则可以打折后购买，同样的事情两者的应对策略却不同，策略可以理解成同一事情在不同场景下的不同应对措施

同样，我们在编程过程中也会遇到类似的情况，例如有一个类表示企业员工，其中有工号和年龄两个属性，现在有一个场景需要根据工号id对两个不同的员工对象进行比较排序：

public class Employee {

    private int empNo;

    private int age;

    public Employee(int empNo, int age) {
        this.empNo = empNo;
        this.age = age;
    }
}

常见的写法可以自定义一个比较方法例如 public int compareTo(T o); 使用方法为 a.compareTo(b)；当返回 1 时表示 a > b ，当返回 0 时 a == b，当返回 -1 时 a < b ，不过这个方法不需要我们自定义，因为 jdk 中已经有了一个这样的接口定义 Comparable，我们直接实现 Comparable 即可
java.lang.Comparable

public class Employee implements Comparable<Employee> {

    private int empNo;

    private int age;

    public Employee(int empNo, int age) {
        this.empNo = empNo;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "empNo=" + empNo +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Employee o) {
        return this.empNo < o.empNo ? -1 : this.empNo == o.empNo ? 0 : 1;
    }
}

编写测试类：

public class EmployeeTest {

    public static <T> T[] sort(T[] arrays) {

        for (int i = arrays.length - 1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                if (((Comparable<T>) arrays[j]).compareTo(arrays[j + 1]) >= 0) {
                    T temp = arrays[j + 1];
                    arrays[j + 1] = arrays[j];
                    arrays[j] = temp;
                }
            }
        }
        return arrays;
    }

    public static void main(String[] args) {
        Employee a = new Employee(0, 40);
        Employee b = new Employee(100, 20);

        Employee[] arrays = {a, b};

        // 排序
        sort(arrays);

        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]);
        }

    }
}

下面有两个对象 a 和 b，工号分别为 0 和 100 ，根据工号排序后输出结果为：

Employee{empNo=0, age=40}
Employee{empNo=100, age=20}

通过以上例子很容易对 Employee 数组排序，但是现在情况有变，需要根据年龄对 Employee 数组排序，如何处理呢，更改 compareTo 内容显然不合适，因为两种比较方式都有不同的使用场景，这时候我们需要根据不同场景提供不同解决方案
例如将 compareTo 中的实现代码提取出来

java.util.Comparator

JDK 提供了类似的解决方案，比如 java.util.Comparator 接口，我们可以通过实现 Comparator 接口定义不同的比较策略

int compare(T var1, T var2);

例如：

// 根据工号比较对象大小
public class EmpNoStrategy implements Comparator<Employee> {

    @Override
    public int compare(Employee o1, Employee o2) {
        return o1.getEmpNo() < o2.getEmpNo() ? -1 : o1.getEmpNo() == o2.getEmpNo() ? 0 : 1;
    }
}

// 根据年龄比较对象大小
public class EmpAgeStrategy implements Comparator<Employee> {

    @Override
    public int compare(Employee o1, Employee o2) {
        return o1.getAge() < o2.getAge() ? -1 : o1.getAge() == o2.getAge() ? 0 : 1;
    }
}

改写测试类：

如下，改写了排序方法，在方法参数中新增了 Comparator 形参，比较大小时使用的便是 comparator 的 compare 方法，而不是 Employee 的 compareTo 方法

public class EmployeeTest2 {

    public static <T> T[] sort2(T[] arrays, Comparator comparator) {

        for (int i = arrays.length - 1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                if (comparator.compare(arrays[j], arrays[j + 1]) >= 0) {
                    T temp = arrays[j + 1];
                    arrays[j + 1] = arrays[j];
                    arrays[j] = temp;
                }
            }
        }
        return arrays;
    }


    public static void main(String[] args) {
        Employee a = new Employee(0, 40);
        Employee b = new Employee(100, 20);

        Employee[] arrays = {a, b};

        // 可以更改为不同策略
        Comparator comparator = new EmpNoStrategy();

        // 排序
        sort2(arrays,comparator);

        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]);
        }

    }
}

如果要按年龄排序只需要更改策略即可，而且后续如果有新增的需求则只需要新增策略即可：

Comparator comparator = new EmpAgeStrategy();

JDK 排序工具类

上面例子只是为了演示策略模式的定义以及实现，实际上JDK 已经为我们提供了排序方法，使用方式如下：

public class EmployeeTest3 {

    public static void main(String[] args) {
        Employee a = new Employee(0, 40);
        Employee b = new Employee(100, 20);

        Employee[] arrays = {a, b};

        Comparator comparator = new EmpNoStrategy();

        Collections.sort(Arrays.asList(arrays),comparator);

        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]);
        }

    }
}