策略模式應用場景的探討

一、排序演算法

在實際開發中，我們需要對數據進行排序。常用的排序演算法有冒泡排序、插入排序、選擇排序、快速排序等。這些演算法雖然思路不同，但實現方式有相似之處——它們都需要進行比較，並按照一定規則對數據進行交換或移動。

可以使用策略模式對排序演算法進行封裝，將演算法抽象成一個演算法族，每個具體的排序演算法都是一個演算法。定義一個排序策略介面，將每個具體的排序演算法實現該介面，並定義一個上下文類，通過該類的setStrategy方法動態地設置不同的排序策略，從而達到在運行時動態地切換不同的排序演算法，提高了靈活性。

public interface SortStrategy {
    public <T extends Comparable> void sort(List list);
}

public class BubbleSort<T extends Comparable> implements SortStrategy {
    public void sort(List list) {
        //冒泡排序演算法
    }
}

public class InsertSort<T extends Comparable> implements SortStrategy {
    public void sort(List list) {
        //插入排序演算法
    }
}

public class QuickSort<T extends Comparable> implements SortStrategy {
    public void sort(List list) {
        //快速排序演算法
    }
}

public class Context<T extends Comparable> {
    private SortStrategy strategy;
    public void setStrategy(SortStrategy strategy) {
        this.strategy = strategy;
    }
    public void sort(List list) {
        strategy.sort(list);
    }
}

二、支付方式

隨著互聯網的發展，電子商務越來越成為一種主要的商業模式，不同的商家需要提供不同的支付方式來滿足客戶的需求。比較常用的支付方式有支付寶、微信支付、銀行卡支付等。這些支付方式的實現方式不同，但功能相似，都需要進行支付操作。

可以使用策略模式對支付方式進行封裝，將每一種支付方式抽象成一個演算法族，每個具體的支付方式可以作為一個演算法。定義一個支付策略介面，將每個具體的支付方式實現該介面，然後將不同的支付方式作為不同的策略，通過上下文類動態地將不同的支付方式設置為當前的支付策略，從而在運行時動態切換支付方式。

public interface PayStrategy {
    public String pay(float price);
}

public class AliPay implements PayStrategy {
    public String pay(float price) {
        //支付寶支付
    }
}

public class WeChatPay implements PayStrategy {
    public String pay(float price) {
        //微信支付
    }
}

public class BankPay implements PayStrategy {
    public String pay(float price) {
        //銀行卡支付
    }
}

public class PayContext {
    private PayStrategy strategy;
    public void setStrategy(PayStrategy strategy) {
        this.strategy = strategy;
    }
    public String pay(float price) {
        return strategy.pay(price);
    }
}

三、動態解析語言

動態解析語言是指在運行時根據代碼動態構建程序的語言，比如Javascript、Ruby等。在這些語言中，經常會出現需要對不同類型的數據進行操作的情況。比如，Javascript中有Number、String等不同的數據類型，需要對這些數據類型進行不同的操作。

可以使用策略模式對動態解析語言中的操作進行封裝，將每個操作抽象成一個演算法族，每個具體的操作可以作為一個演算法。定義一個處理策略介面，將每個具體的操作實現該介面，並通過上下文類將不同的操作動態地設置為當前的處理策略，實現在運行時動態地切換不同的操作。

public interface ScriptStrategy {
    public Object execute(Object obj);
}

public class NumberAddStrategy implements ScriptStrategy {
    public Object execute(Object obj) {
        //對Number類型執行加法操作
    }
}

public class StringReplaceStrategy implements ScriptStrategy {
    public Object execute(Object obj) {
        //對String類型執行替換操作
    }
}

public class ScriptContext {
    private ScriptStrategy strategy;
    public void setStrategy(ScriptStrategy strategy) {
        this.strategy = strategy;
    }
    public Object execute(Object obj) {
        return strategy.execute(obj);
    }
}

四、圖像處理

圖像處理是指對圖像進行各種處理的技術，比如圖像的縮放、旋轉、裁剪、濾鏡等。不同的圖像處理方法需要不同的演算法來實現。

可以使用策略模式對圖像處理方法進行封裝，將每個處理方法抽象成一個演算法族，每個具體的處理方法可以作為一個演算法。定義一個圖像處理策略介面，將每個具體的處理方法實現該介面，並通過上下文類將不同的處理方法動態地設置為當前的策略，實現在運行時動態地切換不同的處理方法，提高了處理效率和靈活性。

public interface ImageProcessStrategy {
    public Image process(Image input);
}

public class ResizeStrategy implements ImageProcessStrategy {
    public Image process(Image input) {
        //對圖像進行縮放
    }
}

public class RotateStrategy implements ImageProcessStrategy {
    public Image process(Image input) {
        //對圖像進行旋轉
    }
}

public class FilterStrategy implements ImageProcessStrategy {
    public Image process(Image input) {
        //對圖像進行濾鏡處理
    }
}

public class ImageContext {
    private ImageProcessStrategy strategy;
    public void setStrategy(ImageProcessStrategy strategy) {
        this.strategy = strategy;
    }
    public Image process(Image input) {
        return strategy.process(input);
    }
}

五、召喚師峽谷遊戲角色攻擊行為

召喚師峽谷是一款網路遊戲，在遊戲中不同的角色擁有不同的攻擊方式。比如，法師可以發動技能攻擊，而刺客更善於使用短線攻擊等。

可以使用策略模式對角色攻擊行為進行封裝，將每個攻擊方式抽象成一個演算法族，每個具體的攻擊方式可以作為一個演算法。定義一個攻擊策略介面，將每個具體的攻擊方式實現該介面，並通過上下文類將不同的攻擊方式動態地設置為當前的攻擊策略，實現在運行時動態地切換不同的攻擊方式。

public interface AttackStrategy {
    public void attack();
}

public class SkillAttack implements AttackStrategy {
    public void attack() {
        //使用技能攻擊
    }
}

public class CloseAttack implements AttackStrategy {
    public void attack() {
        //使用短線攻擊
    }
}

public class LongAttack implements AttackStrategy {
    public void attack() {
        //使用遠程攻擊
    }
}

public class RoleContext {
    private AttackStrategy strategy;
    public void setStrategy(AttackStrategy strategy) {
        this.strategy = strategy;
    }
    public void attack() {
        strategy.attack();
    }
}