Java設計模式之java策略模式詳解

Posted on by

為什麼使用策略模式?

實現某一個功能有多條途徑，每一條途徑對應一種算法，此時我們可以使用一種設計模式來實現靈活地選擇解決途徑，也能夠方便地增加新的解決途徑。

策略模式包含角色

  • Context（環境類）：環境類是使用算法的角色，它在解決某個問題（即實現某個方法）時可以采用多種策略。在環境類中維持一個對抽象策略類的引用實例，用於定義所采用的策略。
  • Strategy（抽象策略類）：它為所支持的算法聲明瞭抽象方法，是所有策略類的父類，它可以是抽象類或具體類，也可以是接口。環境類通過抽象策略類中聲明的方法在運行時調用具體策略類中實現的算法。
  • ConcreteStrategy（具體策略類）：它實現瞭在抽象策略類中聲明的算法，在運行時，具體策略類將覆蓋在環境類中定義的抽象策略類對象，使用一種具體的算法實現某個業務處理。

策略模式的類圖

在這裡插入圖片描述

策略模式需要一個策略接口，不同的策略實現不同的實現類，在具體業務環境中僅持有該策略接口，根據不同的場景使用不同的實現類即可。

面向接口編程，而不是面向實現。

排序案例

對數組進行排序的算法有很多，但是不同的算法在不同的場景下可以發揮更大的效率，例如數據量很大的時候，我們可以使用快速排序，數據量小的時候就可以采用插入排序

在這裡插入圖片描述

抽象策略類

//抽象策略類
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 則是環境角色

參考文章

策略模式

總結

本篇文章就到這裡瞭，希望能夠給你帶來幫助，也希望您能夠多多關註WalkonNet的更多內容！

推薦閱讀：