1. public interface PriceCalculate {
2. public abstract double getFinalPrice();
3. }

然后對其進行實現，分別為不搞活動，折扣，返現活動，分別如下：

1. public class NormalPrice implements PriceCalculate {
2. private double finalPrice = 0d;
3. public double getFinalPrice() {
4. // TODO Auto-generated method stub
5. return finalPrice;
6. }
7. public NormalPrice(double sourcePrice){
8. this.finalPrice = sourcePrice;
9. }
10. }

然后是折扣活動：

1. public class DebetPrice implements PriceCalculate {
2. private double finalPrice = 0d;
3. @Override
4. public double getFinalPrice() {
5. return finalPrice;
6. }
7. public DebetPrice(double sourcePrice,double debet){
8. this.finalPrice = Calculate.mul(sourcePrice, debet);
9. }
10. }

Calculate為工具類，具體代碼在最后。

然后是折現活動：

其中的Calculate為工具類，具體如下：

1. package com.yp.learn.util;
3. import java.math.BigDecimal;
5. public class Calculate {
6. // 默認除法運算精度
7. private static final int DEF_DIV_SCALE = 10;
8. private Calculate(){};
11. /**精確 加法運算
12. * @param d1 被加數
13. * @param d2 加數
14. * @return 和
15. */
16. public static double add(double d1,double d2){
17. BigDecimal b1= new BigDecimal(Double.toString(d1));
18. BigDecimal b2= new BigDecimal(Double.toString(d2));
19. return b1.add(b2).doubleValue();
20. }
21. /**
22. * 提供精確的減法運算。
23. * @param v1 被減數
24. * @param v2 減數
25. * @return 兩個參數的差
26. */
27. public static double sub(double v1, double v2) {
28. BigDecimal b1 = new BigDecimal(Double.toString(v1));
29. BigDecimal b2 = new BigDecimal(Double.toString(v2));
30. return b1.subtract(b2).doubleValue();
31. }
32. /**
33. * 提供精確的乘法運算。
34. * @param v1 被乘數
35. * @param v2 乘數
36. * @return 兩個參數的積
37. */
38. public static double mul(double v1, double v2) {
39. BigDecimal b1 = new BigDecimal(Double.toString(v1));
40. BigDecimal b2 = new BigDecimal(Double.toString(v2));
41. return b1.multiply(b2).doubleValue();
42. }
43. /**
44. * 提供（相對）精確的除法運算，當發生除不盡的情況時，精確到 小數點以后10位，以后的數字四舍五入。
45. * @param v1 被除數
46. * @param v2 除數
47. * @return 兩個參數的商
48. */
49. public static double div(double v1, double v2) {
50. return div(v1, v2, DEF_DIV_SCALE);
51. }
53. /**
54. * 提供（相對）精確的除法運算。當發生除不盡的情況時，由scale參數指 定精度，以后的數字四舍五入。
55. * @param v1 被除數
56. * @param v2 除數
57. * @param scale 表示表示需要精確到小數點以后幾位。
58. * @return 兩個參數的商
59. */
60. public static double div(double v1, double v2, int scale) {
61. if (scale < 0) {
62. throw new IllegalArgumentException(
63. "The scale must be a positive integer or zero");
64. }
65. BigDecimal b1 = new BigDecimal(Double.toString(v1));
66. BigDecimal b2 = new BigDecimal(Double.toString(v2));
67. return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
68. }
70. }

然后策略模式的核心出來了，幾種類都已經實現類，并且都有算法，策略模式要做的，就是 對這個抽象出來的 算法進行 維護，如下：

1. public class PriceCalculateContext {
2. PriceCalculate cal = null;
4. /**無活動情況
5. * @param sourcePrice
6. */
7. public PriceCalculateContext(double sourcePrice){
8. cal = new NormalPrice(sourcePrice);
9. }
11. /**打折活動
12. * @param sourcePrice 原價
13. * @param debet 打折力度
14. */
15. public PriceCalculateContext(double sourcePrice,double debet){
16. cal = new DebetPrice(sourcePrice,debet);
17. }
19. /**返現活動
20. * @param sourcePrice 原價
21. * @param conditionPrice 返現所需滿足額度
22. * @param returnPrice 返現力度
23. */
24. public PriceCalculateContext(double sourcePrice,double conditionPrice,double returnPrice){
25. cal = new ReturnPrice(sourcePrice,conditionPrice,returnPrice);
26. }
28. public double getResult() {
29. return cal.getFinalPrice();
30. }
32. }

與之前的工廠模式相比較，策略模式并沒有提供創建運算類的工廠類，而只是將這些運算類維護在了PriceCalculateContext類中，并且此類中提供了方法getResult（），此方法所調用的剛好是算法接口。那么現在，客戶端的代碼就非常的清晰了：

1. public class Start {
2. public static void main(String[] args) {
3. PriceCalculateContext p = new PriceCalculateContext(100d);
4. System.out.println(p.getResult());
5. p = new PriceCalculateContext(122.2d, 100d, 15d);
6. System.out.println(p.getResult());
7. }
8. }

通過構造價格計算維護類來計算所得的最終結果，計算的具體形式完全對客戶端屏蔽。策略模式最明顯的就是對每種策略所實現的算法進行了封裝，在本例中，就是 PriceCalculateContext的getResult的方法，在后續，可以說如果需要新增新的算法，那么我只需要新增新的算法類，然后在PriceCalculateContext增加相應的映射即可。在客戶端只需要依據不同的參數進行初始化，然后調用的方法不用發生任何改變。