【設計模式輕鬆學】----- 策略模式

什麼是策略模式

 策略模式：定義了算法族，分別封裝起來，讓它們之間能夠互相替換，此模式的變化獨立於使用算法的客戶。--《Head First 設計模式》。

例子說明

 這裏舉的例子是本人給出的一個簡單實現，若是有錯誤請你們指出。在一個商城系統中，商品列表的排序是多變的，可能按價格升序，可能按熱門程度降序，本文例子將使用策略模式解決這種變化。

具體實現

  ProductService類說明：類包含Sort接口，Product指的是須要被排序的數據，sortProduct方法開始排序。Sort是策略模式不一樣算法的一個抽象，利用多態實現價格升序（MoneySort）、熱門程度降序（HotSort）等多種排序方式達到互相替換的目的。

import java.util.List;

public class ProductService {

    private Sort sort;

    private List<Product> products;

    /**
     * 對商品排序
     */
    public void sortProduct() {
        sort.doSort(this.products);
    }

    public ProductService(List<Product> products) {
        this.products = products;
    }

    public void setSort(Sort sort) {
        this.sort = sort;
    }

    public Sort getSort() {
        return sort;
    }

    public List<Product> getProducts() {
        return products;
    }

    public void setProducts(List<Product> products) {
        this.products = products;
    }
}


import java.util.Comparator;
import java.util.List;

/**
 * 按照名稱降序
 */
public class HotSort implements Sort {

    @Override
    public void doSort(List<Product> products) {
        products.sort(new Comparator<Product>() {
            @Override
            public int compare(Product o1, Product o2) {
                return -(o1.getHot() - o2.getHot());
            }
        });
    }
}


import java.util.Comparator;
import java.util.List;

/**
 * 價格升序
 */
public class MoneySort implements Sort{
    @Override
    public void doSort(List<Product> products) {
        products.sort(new Comparator<Product>() {
            @Override
            public int compare(Product o1, Product o2) {
                return (int) (o1.getMoney() - o2.getMoney());
            }
        });
    }
}


public class Product {

    /**
     * 商品名稱
     */
    private String productName;

    /**
     * 商品金額
     */
    private Double money;

    /**
     * 熱門程度
     */
    private Integer hot;

    public Product(String productName, Double money, Integer hot) {
        this.productName = productName;
        this.money = money;
        this.hot = hot;
    }

    public String getProductName() {
        return productName;
    }

    public void setProductName(String productName) {
        this.productName = productName;
    }

    public Double getMoney() {
        return money;
    }

    public void setMoney(Double money) {
        this.money = money;
    }

    public Integer getHot() {
        return hot;
    }

    public void setHot(Integer hot) {
        this.hot = hot;
    }

    @Override
    public String toString() {
        return "Product{" +
                "productName='" + productName + '\'' +
                ", money=" + money +
                ", hot=" + hot +
                '}';
    }
}

 測試類

/**
 * 策略模式：定義了算法族，分別封裝起來，讓它們之間能夠互相轉換，此模式讓算法的變化獨立於使用算法的客戶。
 */
public class StrategyTest {

    public static void main(String[] args) throws Exception {
        List<Product> products = new ArrayList<>();
        products.add(new Product("蘋果",10D,1));
        products.add(new Product("荔枝",20D,41234));
        products.add(new Product("香蕉",30D,11));
        products.add(new Product("獼猴桃",40D,9));
        ProductService productService = new ProductService(products);
        // 按熱門程度降序
        hotSort(productService);
        // 按價格升序
        moneySort(productService);
    }

    /**
     * 按價格升序
     * @param productService
     */
    private static void moneySort(ProductService productService) {
        productService.setSort(new MoneySort());
        System.out.println("價格升序前：" +productService.getProducts());
        productService.sortProduct();
        System.out.println("價格升序後：" +productService.getProducts());
    }

    /**
     * 按熱門程度降序
     * @param productService
     */
    private static void hotSort(ProductService productService) {
        // 按熱門程度降序
        productService.setSort(new HotSort());
        System.out.println("熱門程度降序前：" +productService.getProducts());
        productService.sortProduct();
        System.out.println("熱門程度降序後：" +productService.getProducts());
    }

 執行結果：

策略模式總結：

  同一業務若是有不一樣的計算方式的話使用策略模式能夠把變化隔離起來，在不改動已有的代碼下經過新增實現類就能夠切換算法，但開發者必須知道具體的算法，好比上面的HotSort,MoneySort。