重构到模式

今天，BJDP的伍斌老师提出一个有意思的题

假设出版社要促销一套哈利波特图书，该套图书共5集，每集单册购买8元。若任意两集各买一本，打95折；若任意三集各买一本，打9折；若任意四集各买一本，打8折；若所有这五集都各买一本，打75折。上述优惠之外的单册还是按8元一本计价。比如五集各买一本之外再加一本第一集，五本书打75折，这本另加的第一集按8元计价。

 

这个问题的答案是51.2。但是用程序应该如何实现呢？

 

先是写了套代码：

public double buy(Map<Book, Integer> books) {

        int count = count(books);
        double minPrice = count * 8;    //TODO I really hate this 8.

        //TODO I doubt it could work well if the count is too big.
        //TODO I think it needs another alogrithm to count if bought all 5 kinds books, not only 5 piece of books.
        for (int i = 0; i < count; i++) {
             Discount discount1 = DiscountFactory.create(i);
             Discount rest = DiscountFactory.create(count - i);
             double price = discount1.price() + rest.price();
             System.out.println(discount1.price() +"+" + rest.price());
             minPrice = Math.min(price, minPrice);
        }

        return minPrice;
    }

但是这套代码还是有很多问题的。

比如：图书的种类没有记入统计，而是仅仅按照数量来计算的。

对于这个题目来说，首先打折的方式可以用策略模式来实现

public interface Discount {
    public double price();
}

public class Trois implements Discount {
    public double price() {
        return 8 * 3 * 0.9;
    }
}

public class Quatre implements Discount {
    public double price() {
        return 8 * 4 * 0.8;
    }
}

public class Cenq implements Discount {
    public double price() {
        return 8 * 5 * 0.75;
    }
}

还有不打折的情形

public class None  implements Discount {

    private int count;
    public None(int count) {
        this.count= count;

    }
    public double price() {
        return 8 * count;
    }
}

再配合一个工厂，那么外部就可以使用了。

public class DiscountFactory {
    public static Discount create(int count) {
        switch (count) {
            case 3:
                return new Trois();
            case 4:
                return new Quatre();
            case 5:
                return new Cenq();
            default:
                return new None(count);
        }
    }
}

对于总价计算部分，我是这样考虑的：

首先，挑出几本书，进行打折计算，然后再挑出一些，直到最后无法打折为止。

但是挑选的策略有很多种组合，这里采用了两种策略：

1. 按照最多组合优先

    即，先选5本组合的，再选4本组合的，从数量多的数目开始挑选，确保剩下的尽可能的出现组合，而获得更多的优惠。

2.按照最优组合优先

    即，两个4本比一个5本加一个3本更优惠。

    那么就按照上述同样的算法，只是先挑选4本的。

而先选择3本毫无优势可言，则直接放弃。

package discount; /**
 * Created with IntelliJ IDEA.
 * User: wanghongliang
 * Date: 13-7-4
 * Time: 上午9:14
 * To change this template use File | Settings | File Templates.
 */

import java.util.*;

import book.Book;
import book.HarryPotter;

public class Strategy {

    public double buy(Map<Book, Integer> books) {

        double price1 = buyAsLowerAsPossible(clone(books));
        double price2 = buyAsSmartAsPossible(clone(books));

        return  Math.min(price1, price2);
    }

    private Map<Book, Integer> clone(Map<Book, Integer> books) {
        Map<Book, Integer> target = new HashMap<Book, Integer>();
        Iterator iterator = books.keySet().iterator();
        while(iterator.hasNext()) {
            Book book = (Book)iterator.next();
            Integer value = books.get(book);
            target.put(book, value);
        }
        return target;
    }

    public double buyAsSmartAsPossible(Map<Book, Integer> books)  {
        double minPrice =  new None(count(books)).price();

        double price = 0;
        while(count(books) > 0) {
            int dis = pickBooksAsSmartAsPossible(books);
            Discount discount = DiscountFactory.create(dis);
            price += discount.price();
        }

        return Math.min(minPrice, price);
    }

    public double buyAsLowerAsPossible(Map<Book, Integer> books) {
        double minPrice =  new None(count(books)).price();

        double price = 0;
        while(count(books) > 0) {   //There's book left.
            int dis = pickBooksAsMoreAsPossible(books);
            Discount discount = DiscountFactory.create(dis);
            price += discount.price();
        }

        return Math.min(minPrice, price);
    }

    private int pickBooksAsSmartAsPossible(Map<Book, Integer> books) {
        if (hasBooks(books, 4)) {
            removeBooks(books, 4);
            return 4;
        }
        if (hasBooks(books, 5)){
            removeBooks(books, 5);
            return 5;
        }
        if (hasBooks(books, 3)) {
            removeBooks(books, 3);
            return 3;
        }
        removeBooks(books, 1);
        return 1;
    }
    private int pickBooksAsMoreAsPossible(Map<Book, Integer> books) {
        if (hasBooks(books, 5)){
            removeBooks(books, 5);
            return 5;
        }
        if (hasBooks(books, 4)) {
            removeBooks(books, 4);
            return 4;
        }
        if (hasBooks(books, 3)) {
            removeBooks(books, 3);
            return 3;
        }
        removeBooks(books, 1);
        return 1;
    }

    private boolean hasBooks(Map<Book, Integer> books, int kinds) {
         return books.keySet().size() >= kinds;
    }

    private void removeBooks(Map<Book, Integer> books, int kinds) {
        List<Book> keys = new ArrayList<Book>();
        List<Integer> values = new ArrayList<Integer>();
        sortBooksDesc(books, keys, values);
        reduceCount(books, kinds, keys);
        removeEmptyBookKeys(books);
    }

    private void sortBooksDesc(Map<Book, Integer> books, List<Book> keys, List<Integer> values) {
        Iterator iterator = books.keySet().iterator();
        while(iterator.hasNext()) {
            Book book = (Book)iterator.next();
            Integer count = books.get(book);
            int index = findPlace(values, count);
            keys.add(index, book);
            values.add(index, count);
        }
    }

    private void removeEmptyBookKeys(Map<Book, Integer> books) {
        removeBook(books, HarryPotter.BOOK_1);
        removeBook(books, HarryPotter.BOOK_2);
        removeBook(books, HarryPotter.BOOK_3);
        removeBook(books, HarryPotter.BOOK_4);
        removeBook(books, HarryPotter.BOOK_5);
    }

    private void reduceCount(Map<Book, Integer> books, int kinds, List<Book> keys) {
        for (int i = 0; i < kinds; i++) {
            Book book = keys.get(i);
            System.out.println("reduce from " + book.index);
            Integer count = books.get(book);

            if (count > 0 )  {
                books.put(book, count - 1);
            }
        }
    }

    private int findPlace(List<Integer> values, Integer value) {
        for (int i = 0; i < values.size(); i++) {
             if (values.get(i) <= value) {
                  return i;
             }
        }
        return values.size();
    }

    private void removeBook(Map<Book, Integer> books, Book key) {
        if(books.containsKey(key) && books.get(key) ==0) {
            System.out.println("remove book " + key.index);
            books.remove(key);
        }
    }

    private int count(Map<Book, Integer> books) {
        int count = 0;
        Iterator iterator = books.keySet().iterator();

        while(iterator.hasNext()) {
            Book book = (Book)iterator.next();
            count += books.get(book);
        }

        return count;
    }
}

上述代码经过如下测试，都已经通过了。

public static void main(String [] args) {
        Strategy strategy = new Strategy();
        Map<Book, Integer> cart = new HashMap<Book, Integer>() ;

        cart.put(HarryPotter.BOOK_1, 2);
        cart.put(HarryPotter.BOOK_2, 2);
        cart.put(HarryPotter.BOOK_3, 2);
        cart.put(HarryPotter.BOOK_4, 1);
        cart.put(HarryPotter.BOOK_5, 1);

        double price = strategy.buy(cart);
        System.out.println("the discounted price is :" + price); //Hope it is 51.2;


        cart.put(HarryPotter.BOOK_1, 1);
        cart.put(HarryPotter.BOOK_2, 1);
        cart.put(HarryPotter.BOOK_3, 2);
        cart.put(HarryPotter.BOOK_4, 3);
        cart.put(HarryPotter.BOOK_5, 4);

        price = strategy.buy(cart);
        System.out.println("the discounted price is :" + price); //Hope it is 75.2;


        cart.put(HarryPotter.BOOK_1, 2);
        cart.put(HarryPotter.BOOK_2, 2);
        cart.put(HarryPotter.BOOK_3, 2);
        cart.put(HarryPotter.BOOK_4, 2);
        cart.put(HarryPotter.BOOK_5, 2);

        price = strategy.buy(cart);
        System.out.println("the discounted price is :" + price); //Hope it is 60;
    }

注：如果上述组合不是僵化的而是每次都可以灵活选择的话，那么对于5,5,3和5,4,4这种情形就可以做出优选了。

总结：

    策略模式一般来说需要配合工厂模式，让外部可以调用。

    职责链模式的基本表达可以写成：doE(doD(doC(doB(doA(param)))));   也就是说，对同一个事物的不停采取不同策略操作。

             但是在本例中，下次采取什么策略需要进行计算，所以不是简单的传递，而是：

  while (....) {            

          Strategy strategy = StrategyFactory.create(param));

          strategy.execute(param);

  }

上述代码没有符合这个模式，还需要继续改进。

 再补充一下，图书信息：

public class Book {
    public String name;
    public int index;
    public Book(String name, int index) {
        this.name = name;
        this.index = index;
    }
}

public class HarryPotter {
    public static final Book BOOK_1 = new Book("philosophy stone", 1);
    public static final Book BOOK_2 = new Book("secret chamber", 2);
    public static final Book BOOK_3 = new Book("prisoner of azkaban", 3) ;
    public static final Book BOOK_4 = new Book("goblet of fire", 4) ;
    public static final Book BOOK_5 = new Book("order of phoenix", 5);
    //NOT FOR SALE currently public static final book.Book BOOK_6 = new book.Book("half blood prince");
    //NOT FOR SALE currently public static final book.Book BOOK_7 = new book.Book("deathly hallow");
}

 遗漏了一个2本的情况

public class Duex implements Discount {
    public double price() {
        return 8 * 2 * 0.95;
    }
}

工厂也要变一下

public class DiscountFactory {
    public static Discount create(int count) {
        switch (count) {
            case 2:
                return new Duex();
            case 3:
                return new Trois();
            case 4:
                return new Quatre();
            case 5:
                return new Cenq();
            default:
                return new None(count);
        }
    }
}