从“假如有以下几种价格10,20，50，请你代码实现将他们排序输出”看设计模式中的策略模式

今天重温了一下策略模式，将自己的一些感悟与大家分享。。。本人只是技术渣渣，所理解的东西的难免会有很大的局限性甚至是错误，还请各位带着批判的眼光去看待。。。。不喜请勿吐槽

         定义：策略模式属于设计模式中的对象行为型模式，它将用到的算法单独抽象成一个单独的类。通常，我们在多个类完成同一件事情，仅仅完成的方式不同时，我们可以考虑使用这种设计模式。

         

         举例：相信，很多人在看到“假如有以下几种价格10,20,50，请你代码实现将他们排序输出”这种题目的时候，很快就写出了以下代码，写之前还不忘了问一下，“对时间复杂度有什么要求吗？？？需要处理的数据规模大概是多少？？？”，这时候，别人通常都会面带微笑，说，“对时间复杂度没有要求，数据规模你假设是XX就行了”之类的话。。。

        很快的，类似于下面的代码就出来了

         

[cpp] view plaincopyprint?

1. /* 
2.  * price.cpp 
3.  * 
4.  *  Created on: 2014年5月11日 
5.  *      Author: pc 
6.  */  
7.   
8. #include <iostream>  
9. #include <cstdio>  
10. #include <algorithm>  
11.   
12. using namespace std;  
13.   
14. int n;  
15. int price[100];  
16.   
17. /** 
18.  * 处理输入逻辑 
19.  */  
20. void hanldeInput() {  
21.     int i;  
22.     for (i = 0; i < n; ++i) {  
23.         scanf("%d", &price[i]);  
24.     }  
25. }  
26.   
27. /** 
28.  *相比这里很多朋友会绞尽脑汁的想各种各样的排序算法.. 
29.  *其实最后写出来的话，大部分用到的算法还是: 冒泡排序、选择排序、插入排序、希尔排序、快速排序、归并排序、堆排序 
30.  */  
31. void sort(int price[]) {  
32.     for(int i = n ; i > 0 ; --i){  
33.         for(int j = 0 ; j < i-1 ; ++j){  
34.             if(price[j] > price[j+1]){  
35.                 swap(price[j],price[j+1]);  
36.             }  
37.         }  
38.     }  
39. }  
40.   
41. /** 
42.  * 处理输出逻辑 
43.  */  
44. void myprint(int price[]) {  
45.     //TODO 此处将他们输出  
46.     for(int i = 0 ; i < n ; ++i){  
47.         printf("%d ",price[i]);  
48.     }  
49.   
50. }  
51.   
52. int main() {  
53.     while (scanf("%d", &n) != EOF) {  
54.         hanldeInput();  
55.         sort(price);  
56.         myprint(price);  
57.     }  
58. }  

       尽管有的朋友甚至可能还会把上面的输入逻辑、排序逻辑、输出逻辑都写到main方法里面，但是，大部分都会在写完以后在心里骂一句，“靠，老子是XX区的ACM的XX牌的获得者，居然拿这种题来敷衍我。。”靠。。。这是，只见别人还是一如既往的面带微笑。。。。而被面试的人就自我感觉非常良好地离开了。。。。

其实，现在再回首这种题目的时候，再看看若干年前自己写成那样的代码，简直不忍直视。。。

以下谈谈自己遇到类似的问题时，自己的一些思考。

个人觉得，这种题目可能更多关注的不是你的代码实现，而是你在写代码时的架构。

以下是自己的一些思考

1）根据OOP“一切皆对象”的原则，price应该设计成一个类，而不是仅仅是一个int[]。

2）上面的排序逻辑只能作用于Int[],要是某一天用户有一堆double[]类型的数据需要按同样的逻辑进行排序呢？？？

那你难道ctrl+c\ctrl+v一遍，然后把参数改成double[]类型的？？现在的sort方法职能作用领域Price类型的数据，

要是某一天需要对Human类型的数据进行排序呢？？？？难道又重写一遍逻辑类似的sort方法而仅仅是因为参数的

类型不一样？？？

3）上面的排序逻辑已经写死了，就是用的冒泡排序。要是某一天用户高兴，说我就是喜欢用希尔排序。那你是不是又要把那一坨代码改改改。。。这。。。

        这时，可能有一些朋友会说，“我才不管，反正他问的是：假如有以下几种价格10,20,50，请你代码实现将他们排序输出，我只要实现这一个逻辑就行了，管他呢”。。是的，其实这种题只是用户的某一种情况的下的需求的简化一下的版本而已。。。例如今天用户就只说，“我有一堆的Price，你帮我排序一下”，明天他可能就会对你说，“我也有一堆的Human，你也帮我排序一下吧”。。。后天有会对你说，“你之前的那个算法我不喜欢，你换一个吧”。。。。这时你会疯掉的。。。。

所以，以下给出我对这一情况下使用策略模式来设计代码的实现

1、MyComparable

[java] view plaincopyprint?

1. public interface MyComparable {  
2.   
3.     public int compareTo(Object o);  
4. }  

2、MyComparator

[java] view plaincopyprint?

1. public interface MyComparator {  
2.   
3.     public int compare(Object o1,Object o2);  
4. }  

3、PriceNumComparator

[java] view plaincopyprint?

1. public class PriceNumComparator implements MyComparator {  
2.   
3.     @Override  
4.     public int compare(Object o1, Object o2) {  
5.         Price p1 = (Price)o1;  
6.         Price p2 = (Price)o2;  
7.           
8.         if(p1.getNum() > p2.getNum()){  
9.             return 1;  
10.         }else if(p1.getNum() < p2.getNum()){  
11.             return -1;  
12.         }  
13.         return 0;  
14.     }  
15.       
16. }  

4、PriceWeightComparator

[java] view plaincopyprint?

1. public class PriceWeightComparator implements MyComparator {  
2.   
3.     @Override  
4.     public int compare(Object o1, Object o2) {  
5.         Price p1 = (Price)o1;  
6.         Price p2 = (Price)o2;  
7.           
8.         if(p1.getWeight() > p2.getWeight()){  
9.             return -1;  
10.         }else if(p1.getWeight() < p2.getWeight()){  
11.             return 1;  
12.         }  
13.           
14.         return 0;  
15.     }  
16.   
17. }  

5、Price

[java] view plaincopyprint?

1. public class Price implements MyComparable{  
2.   
3.     public int num;  
4.     public int weight;  
5.     public MyComparator comparator  = new PriceWeightComparator();  
6.       
7.     public int getNum() {  
8.         return num;  
9.     }  
10.     public void setNum(int num) {  
11.         this.num = num;  
12.     }  
13.     public int getWeight() {  
14.         return weight;  
15.     }  
16.     public void setWeight(int weight) {  
17.         this.weight = weight;  
18.     }  
19.       
20.     public Price() {  
21.         // TODO Auto-generated constructor stub  
22.     }  
23.     public Price(int num, int weight) {  
24.         super();  
25.         this.num = num;  
26.         this.weight = weight;  
27.     }  
28.       
29.       
30.     @Override  
31.     public String toString() {  
32.         return "Price [num=" + num + ", weight=" + weight + "]";  
33.     }  
34.       
35.     @Override  
36.     public int compareTo(Object o) {  
37.         return comparator.compare(this, o);  
38.     }  
39.       
40.       
41. }  

6、Sorter

[java] view plaincopyprint?

1. public class Sorter {  
2.   
3.     public static void sort(Object[] os){  
4.         int length = os.length;  
5.         for(int i = length ; i > 0 ; --i){  
6.             for(int j = 0 ; j < i-1 ; ++j){  
7.                 MyComparable c1 = (MyComparable) os[j];  
8.                 MyComparable c2 = (MyComparable) os[j+1];  
9.                   
10.                 if(c1.compareTo(c2) == 1){  
11.                     swap(os, j, j+1);  
12.                 }  
13.             }  
14.         }  
15.     }  
16.       
17.     public static void swap(Object[] os ,int i,int j){  
18.         Object temp = os[i];  
19.         os[i] = os[j];  
20.         os[j] = temp;  
21.     }  
22.       
23.     public static void print(Object[] os){  
24.         int length = os.length;  
25.           
26.         for(int i = 0 ; i < length ; ++i){  
27.             System.out.print(os[i] + " ");  
28.         }  
29.           
30.         System.out.println();  
31.     }  
32. }  

7、Main //用来测试

[java] view plaincopyprint?

1. public class Main {  
2.   
3.     public static void main(String[] args) {  
4.         Price[] prices = {  
5.             new Price(1, 1),  
6.             new Price(2, 2),  
7.             new Price(3, 3)  
8.         };  
9.           
10.           
11.         Sorter.sort(prices);  
12.         Sorter.print(prices);  
13.     }  
14. }  

写在最后：

设计模式是一种“把简单东西复杂化”的一种东西，其实更准确的来说，它是一种要求你在开始实现某一个具体功能之前就把相应的架构给想好的开发思路。。。。