设计模式 -- 模板模式 / 策略模式

1 JUnit中的设计模式（上）

1.1测试用例：

public class BubbleSorterTests extends TestCase{

       private Integer[] array;

       private Sorter sorter;

       protected void setUp(){ //测试所需资源初始化

            array=new Integer[]{5,4,9,7,6,3,8,1,0,2};

            sorter=new BubbleSorter();

       }

       public void testSort(){

            Sortable sortable=new ArraySortable(array);

            Comparator comparator=new IntegerComparator();

            sorter.sort(sortable,comparator);

            for(int i=0;i<10;i++){

                 assertEquals(i,array[i].intValue);

            }

       }

}



1.2实现单元测试的步骤：

1.创建测试类，从TestCase派生

2.初始化---覆盖基类的方法： protected void setUp()

3.书写测试方法---命名规则：public void testXyz()

4.清除环境--覆盖基类的方法：protected void tearDown()



public abstract class TestCase extends Assert implements Test{

      public void runBare()throws throwable{//模板方法：step 1:setup();step 2:runTest(); step3: tearDwon

           Throwable exception=null;

           setUp(); // 初始化资源

           try{

               runTest(); //执行测试

            }catch(Throwable running){

                   exception=running;

           }finally{

                   try{

                       tearDown(); //清理资源

                   }catch(Throwable tearDown){

                       if(exception==null){

                            exception=tearDown;

                       }

                   }

           }

           if(exception!=null){throw exception;}

    }

   protected void runTest()throws Throwable{//利用动态机制调用testXyz()}

   protected void setUp() throws Exception{ }

   protected void tearDown() throws Exception{ }

}



2 模板方法模式：Template Method

模板方法模式是扩展功能的最基本模式之一---------类的行为模式

模板方式模式是通过“继承”的方法来实现扩展

• 基类负责算法的轮廓和框架

• 子类负责算法的具体实现

模板方法的形式：

抽象方法：优选方法

• protected abstract void step1();

• 强制子类实现该步骤

具体方法：

• protected void doSomething(){.....}

• 父类提供默认方法，子类如果不需要，则不覆盖；如果需要则覆盖

• 如果明确告诉子类“不要覆盖它”，最好标明：final

钩子方法：

• protected  void setUp(){... } 

• 空的实现 （缺省适配器模式）

• 子类可选择的覆盖之，以便在特定的时机做些事。



2.1测试Sortable:

public abstract class SortableTests extends TestCase{

     protected Sortable<Integer> sortable;

     protected void setUp(){

         Integer[] data=new Integer[10];

         for(int i=0;i<10;i++){

             data[i]=i;

         }

         sortable=createSortable(data);

     }

     protected abstract Sortable<Integer> createSortable(Integer[] data);



     public final void testGet(){.... }

     public final void testSet(){..... }

     public final void testSize(){ assertEquals(10,sortable.size();); }

}



2.2测试ArraySortable

public class ArraySortableTests extends SortableTests{

     @Override

     protected Sortable<Integer> createSortable(Integer[] data){//实现模板方法

          List<Integer> list=Arrays.asLIst(data);

          rturn new ListSortable<Integer>(list);

    }

}

2.3测试ListSortable

public class ListSortableTests extends SortableTests{

     @Override

     protected Sortable<Integer> createSortable(Integer[] data){//实现模板方法

          return new ArraySortable<Integer>(data);

     }

}





3 策略模式（Strategy）:

策略模式是扩展功能的另一种最基本的模式----对象的行为模式

他是通过“组合”的方法来实现扩展：



3.1什么时候使用策略模式？

系统需要在多种算法中选择一种



重构系统时---将条件语句转换成对于策略的多态性调用

3.2策略模式的优点

（对比模板方法）

• 将使用策略的人和策略的具体实现分离

• 策略对象可以组合

3.3策略模式可能存在的问题：

    策略模式仅仅封装了“算法的具体实现”，方便添加和替换算法，但他并不关心何种算法，这个必须由客户端来决定。