谈谈对方法模板设计模式的理解

         套用一下子《大话设计模式》里的模板设计模式的定义:定义一个操作中算法的骨架，而将这些步骤延迟到子类中，模板方法使得子类可以不改变一个算法的结构即可重新定义

该算法的某些特定步骤。

      

模板方法模式：

    定义一个操作中的算法的框架，而将一些步骤延迟到子类中。模板方法模式似的子类不改变一个算法的结构即可重定义该算法的某些特定的步骤。

   【引用一段英文】 Template Method Pattern:Define the skeleton of an algorithmin an operation,deferring some steps to subclasses.Template methodlets subclasses redefine certain steps of an algorithm without changing the algorithm's structure.

模板方法模式的定义：
    1、是一种基于继承的代码的复用技术。
    2、将一些复杂流程的实现步骤封装在一系列基本方法中。
    3、在抽象父类中提供一个称之为模板方法的方法来定义这些基本方法的执行次序，而通过其子类来覆盖某些步骤，
从而使得相同的算法框架可以有不同的执行结果。

一般模板方法模式的结构包括两个角色：
    一个是AbstractClass（抽象类）,另外一个是ConcreteClass(具体子类);
讲了这么多，给出一个实例来具体说明一下：

    比如，以项目小组开发一个java项目来讲解模板方法设计模式。

模板方法：

package com.bjsxt.template;


/**
 * 以开发项目的大体流程讲解一下模板方法设计模式
 * @author Administrator--jiangyu--2014-9-1 下午9:02:12
 *
 */
public abstract class JavaPrograme {
    //编写java代码  抽象方法
    public abstract void writeJavaCode();
    //编写jsp页面   抽象方法
    public abstract void writeJsp();
    //自己实现javascript编写   具体方法
    public void writeJs(){
        System.out.println("在这个项目中，boss写好javascript。。。");
    }
    //编写css样式  抽象方法
    public abstract void writeCss();
    
    /**
     * 开发流程的骨架
     */
    public void developmentItem(){
        writeJavaCode();
        writeJsp();
        writeJs();
        writeCss();
        //提供方法来为子类实现反向控制
        if(isQualified()){
            deploy();
        }else {
            System.out.println("项目不可以发布");
        }
    }
    
    //钩子方法  判断是否合格
    public Boolean isQualified(){
        return true;
    }
    
    public void deploy(){
        System.out.println("项目可以发布");
    }
}

具体实现类

【Team1】

package com.bjsxt.concrete;

import com.bjsxt.template.JavaPrograme;

public class Team1 extends JavaPrograme{

    @Override
    public void writeJavaCode() {
        // TODO Auto-generated method stub
        System.out.println("Team1 writeJavaCode...");
    }

    @Override
    public void writeJsp() {
        // TODO Auto-generated method stub
        System.out.println("Team1 writeJsp...");
    }

    @Override
    public void writeCss() {
        // TODO Auto-generated method stub
        System.out.println("Team1 writeCss...");
    }

    @Override
    public Boolean isQualified() {
        // TODO Auto-generated method stub
        return false;
    }
    
}

【Team2】

package com.bjsxt.concrete;

import com.bjsxt.template.JavaPrograme;

public class Team2 extends JavaPrograme {

    @Override
    public void writeJavaCode() {
        // TODO Auto-generated method stub
        System.out.println("Team2 writeJavaCode...");
    }

    @Override
    public void writeJsp() {
        // TODO Auto-generated method stub
        System.out.println("Team2 writeJsp...");
        
    }

    @Override
    public void writeCss() {
        // TODO Auto-generated method stub
        System.out.println("Team2 write css...");
    }

    @Override
    public Boolean isQualified() {
        // TODO Auto-generated method stub
        return true;
    }
    
}

测试类

package com.bjsxt.test;


import org.junit.Test;

import com.bjsxt.concrete.Team1;
import com.bjsxt.concrete.Team2;
import com.bjsxt.template.JavaPrograme;

public class TemplateDemo {
    @Test
    public void demo1(){
        JavaPrograme jp1 = new Team1();
        jp1.developmentItem();
    }
    @Test
    public void demo2(){
        JavaPrograme jp2 = new Team2();
        jp2.developmentItem();
    }
}

执行结果

Team1 writeJavaCode...

Team1 writeJsp...

在这个项目中，boss写好javascript。。。

Team1 writeCss...

项目不可以发布

 

 

 

Team2 writeJavaCode...

Team2 writeJsp...

在这个项目中，boss写好javascript。。。

Team2 write css...

项目可以发布

通过对模板方法模式的分析和理解，可以对该设计模式做如下总结：

模式的优点：
    1、在父类中形式化的定义一个基本实现的大体方向（也即流程），而由具体的子类来实现细节的处理，
    在子类实现详细的处理算法时并不会改变算法中步骤的执行次序。也即顶级的逻辑方法是不能被子类改变的。
    2、提取了类库中的公共行为，将公共行为放在父类中，而通过子类来实现不同的行为。【逻辑的不变+实现的可变】
    3、可以实现一种反向控制结构，通过子类覆盖父类的钩子方法来决定某一特定步骤是否要执行。
    4、更换和增加新的子类很方便，符合单一职责原则和开闭原则。
模式的缺点：
    需要为每一个基本方法的不同实现提供一个子类，如果父类中的可变的基本方法过多的话，将会导致类的个数的增加，系统
也就更加庞大，设计也会越来越抽象。

模式的使用环境：
    1、一次性实现一个算法的不变部分，并将可变的行为留给子类来实现;
    2、如果多个子类中的公共行为比较多，这些公共行为应该被提取出来，并集中到一个公共的父类中，从而避免代码的冗余。
    3、需要通过子类来决定父类算法中的某个步骤是否执行，实现子类对父类的反向控制。

  总之，设计模式的出现是为了在特定的情况下，给程序设计者提供方便，或许是效率上，或许是在代码的复用性或者扩展性等方面。以上就是本人对该设计模式的一点点理解，由于知识有限，某些地方可能有理解不到位，还请给位路过的大虾指点。