从诸葛亮的三个锦囊妙计谈策略模式

                                                从诸葛亮的三个锦囊妙计谈策略模式
 
话说当年东吴孙权为刘备借走了荆州不还而耿耿于怀,却不料甘夫人去世,周郎顿时计上心来,让孙权将其妹嫁与刘备,骗刘备来东吴完婚。刘备又不是傻子,当然知道其中的猫腻,当即表态:打死也不去。诸葛亮却说无妨,当下给了赵云三个锦囊妙计,让他陪刘备去东吴完婚……最后的结果大家都知道,赵云在恰当的时候一一打开三个锦囊妙计,从而将危机一一化解。周瑜只落了个“周郎妙计安天下,赔了夫人又折兵”的笑柄。
这个故事,我们感兴趣的是三个锦囊妙计。诸葛亮一定是运用策略模式的高手,我们想啊:诸葛亮为什么要这么麻烦,做三个锦囊,他完全可以只做一个锦囊,将这三个妙计都写在它上面。可他没有这么做,而是正确的运用了策略模式做了三个锦囊。这样做的好处十分明显:诸葛亮一个锦囊写一个妙计,他的思路十分清晰,不会三个计策相互混乱。而赵云看妙计的时候也十分方便,什么时候看哪个妙计,使用十分方便,如果三个妙计混在一起,他就没这么方便了。
现在看来,这个故事正包含了策略模式的解决问题的思路:解决某一问题有多种方法或算法,如诸葛亮给了三个妙计,类的提供者要将这多种方法或算法独立开来,如诸葛亮将三个妙计分三个锦囊装,类的使用者,如赵云,在相应的条件,如故事中的恰当时间,使用相应的方法或算法。
前面我们说过命令模式,命令模式是对行为的封装;策略模式其实跟它的解决思路一样,是对算法的封装。当然,它们都一样的拥有同一个接口。
下面我们以一些例子来详细的说一说策略模式。
首先的一个例子是我们对数组的排序,对数组的排序有很多算法,我们想做一个由用户指定一个整形数组和对它排序的算法,我们给出结果这样一个方法,我们可以这样做:

public int[] sort(int[] inArray,String type)

{
       if(type.equals(“a”))
        {
               int k = 0;
               for(int i=0;i
               {
                      for(int j=i+1;j
                      {

                             if(inArray[i]> inArray[j])

                             {

                                    k = inArray[i];

                                    inArray[i] = inArray[j];

                                    inArray[j] = k;

                             }
                      }
               }
}
else if(type.equals(“b”))
{
       int k = 0;
       for(int i=0;i< inArray.length;i++)
       {

              for(int j=0;j< inArray.length-i-1;j++)

              {
                     if(inArray [j]> inArray [j+1])
                     {
                            k = inArray [j];
                            inArray [j] = inArray [j+1];
                            inArray [j+1] = k;
                     }
              }
       }
}
}
一看上面的代码,大家就觉得问题很多:第一,所有的算法都搅和在一起,不满足单一职责原则。第二,依赖细节,不满足依赖颠倒原则。第三,扩展性不好,如果要增加一个新的算法,需要对该方法进行改动。
下面我们来看看策略模式的解决思路。
首先是对所有的算法抽象一个接口,这是为了满足扩展性的基本条件,几乎所有的模式都要以接口为基础:
public interface SortAlgorithm
{

        public void sort(int[] inArr);

}
然后是各个算法的具体实现,它们实现了SortAlgorithm接口,完成了对关注点的分离,满足单一职责原则:

public class SortOne implements SortAlgorithm

{

        public void sort(int[] inArr)

        {
               int k = 0;
               for(int i=0;i
               {
                      for(int j=i+1;j
                      {

                             if(inArr[i]> inArr[j])

                             {

                                    k = inArr[i];

                                    inArr[i] = inArr[j];

                                    inArr[j] = k;

                             }
                      }
               }
}
}

public class SortTwo implements SortAlgorithm

{

        public void sort(int[] inArr)

        {
               int k = 0;
       for(int j=0;j< inArr.length-i-1;j++)
       {

              if(inArr[j]> inArr[j+1])

              {
                     k = inArr[j];
                     inArr[j] = inArr[j+1];
                     inArr[j+1] = k;
              }
               }
}
}
然后我们来看客户端的调用:

public int[] sort(int[] inArray,String type)

{
       SortAlgorithm sa;
       if(type.equals(“a”))
        {

               sa = new SortOne();

        }

        else if(type.equals(“b”))

        {

               sa = new SrotTwo();

}
else
{
       ……
}
sa.sort(inArray);
}
上面我们就完成了策略模式对该问题的解决,满足了单一职责原则;有了一定的扩展性,如果新增一个算法的话,去实现SortAlgorithm接口就可以了。
当然,我们在客户端代码可以看到,策略模式依然没有完全去掉客户端对具体实现类的依赖,这使得我们增加一个新的算法以后,仍然需要对客户端进行修改。所以策略模式和命令模式一样,只是初步增加了一定的扩展性。如果要完全去掉客户端对具体类的依赖,可以结合工厂模式来对该问题作进一步优化,具体做法大家可以自己做,这里不再讲述。
所谓策略模式,简单说来就是对算法的封装。在实际的编码过程中,我们会遇到各种各种的选择算法的问题,这时候就可以使用策略模式了,下面以一个例子来作为本文的结束。
假设我们有一个POJO类:Employee,里面存储了很多用户的信息,如下:
public class Employee
{

        private int id;

        private String name;

        private double servedYears;

        ……

        public void setId(int id)

        {
               this.id = id;
}
public int getId()
{
       return this.id;
}

public void setName(String name)

{
       this.name = name;
}
public String getName()
{
       return this.name;
}

public void setServedYears(double servedYears)

{
       this.servedYears = servedYears;
}

public double getServedYears()

{
       return this.servedYears;
}
……
}
现在我们有一个关于Employee的数组,需要对数组进行排序,我们知道该使用Arrays.sort()对该数组进行排序,但是在使用该方法的时候,我们首先要实现Comparator接口,如下:

Arrays.sort(emps,new Comparator(){

        Public int compare(Object o1,Object o2)

        {

               return ((Employee)o1).getServedYears()-((Employee)o2).getServedYears();

}
});
上面实现了一个对POJO对象的排序过程,现在的问题是我们分别需要对Employee类的id、name和servedYears为索引进行排序。我们可以看出,这明显是多个算法的问题,可以使用策略模式来解决问题:
以id为索引的比较器:

public class IdComparator implements Comparator

{

        Public int compare(Object o1,Object o2)

        {

               return ((Employee)o1).getId()-((Employee)o2).getId();

}
}
以name为索引的比较器:

public class NameComparator implements Comparator

{

        Public int compare(Object o1,Object o2)

        {

               return ((Employee)o1).getName()-((Employee)o2).getName();

}
}
以servedYears为索引的比较器:

public class ServedYearsComparator implements Comparator

{

        Public int compare(Object o1,Object o2)

        {

               return ((Employee)o1).getservedYears()-((Employee)o2).getServedYears();

}
}
然后,我们做一个工厂来获取具体的比较器:
public class Factory
{

        public static Comparator getInstance(String type)

        {
               if(type.equals(“id”))
               {
                      return new IdComparator();
}
else if(type.equals(“name”))
{
   return new NameComparator();
}
else
{
   return ServedYearsComparator();
}
}
}
那么我们就可以对客户端进行编码了:

public void sort(Employee[] emps,String type)

{
       Arrays.sort(emps,Factory.getInstance(type));
}
我们可以看到,结合了工厂模式的策略模式的确使多算法的问题得到了很好的解决:抽取了各个算法来单独关注,满足了单一职责原则;满足了依赖颠倒原则,有了很好的扩展性。等等。
还等什么呢?赶快到实践中去灵活运用这些模式吧!

你可能感兴趣的:(模式)