首页 > 代码库 > 方法模版模式(设计模式_11)【精品博客】

方法模版模式(设计模式_11)【精品博客】

今天给大家介绍的是:模版方法模式,这个模式非常的常见,很多开发者,无意中其实就已经用到了,也非常简单,只是还不知道,这属于一种设计模式而已,而关于这个设计模式,在网上有很多专业性词语来说明,看的人审美疲劳。


其实这个设计模式,通俗易懂的来讲,就是把子类重复的东西,定义到父类中模块化起来,父类只需要去管理好算法流程框架,把经常变化的点,让子类去继承完成。


我们看下面几道案例来理解就OK了:


案例一:

  • 在很久很久以前,有一个小山村,住在这里面的小朋友上学无比困难,因为这个小村庄太过于偏僻,像是被大山围住了一样,出行非常不便,

  • 于是这个小山村里面的村民,就集体花钱给这个小村庄办了一个小学校,经过两年后,也正是的开始在上课了,晓明是这个学校的学生,学习非常

  • 努力,学习也是这个班级比较厉害的,有一次班级考试,由于学校资金紧缺,没有试卷,所以学校老师把题目写在黑板上,让学生们抄下来,作为

  • 试卷题目,由于之前晓明看书离书比较近,眼睛成了近视眼,把黑板上的题目抄错了,把里面的数字7抄写成了1,晓明自信满满的完成了考试,

  • 也认为没有问题,而老师在批改的时候不会很认真的看题目,只是去对照答案…,最后等试卷发下来才知道原因,回到家中还被父母批评,

  • 晓明很苦恼…….
    我们先把晓明的这次题目抄错:用代码实现…..

晓明:

/**
 * 用此类模拟晓明
 * @author Liudeli
 */

public class XiaoMing {

    /**
     * 题目一
     * @param answer 传入参数为答案
     */
    public void subject1(String answer) {

        System.out.println("1)在Java中,如果父类中的某些方法不包含任何逻辑,并且需要有子类重写,应该使用()关键字来申明父类的这些方法。"
                + "a) Final "
                + "b) Static "
                + "c) Abstract "
                + "d) Void"
                + "");

        System.out.println("答案是:" + answer);

    }

    /**
     * 题目二
     * @param answer 传入参数为答案
     */
    public void subject2(String answer) {

        System.out.println("2) 在java中,以定义了两个接口B和C,要定义一个实现这两个接口的类,以下语句正确的是()"
                + "a) interface A extends B,C  "
                + "b) interface A implements B,C  "
                + "c) class A implements B,C"
                + "d) class A implements B,implements C "
                + "");

        System.out.println("答案是:" + answer);

    }

    /**
     * 题目三
     * @param answer 传入参数为答案
     */
    public void subject3(String answer) {

        System.out.println("3) 在java中,在定义类时加上修饰符()可以实现该类不能在本类被实例化。"
                + "a) Final  "
                + "b) Public  "
                + "c) c) Private "
                + "d) Abstract "
                + "");

        System.out.println("答案是:" + answer);

    }

}

晓明同学A:

/**
 * 同学A
 * @author Liudeli
 */
public class StudentA {

    /**
     * 题目一
     * @param answer 传入参数为答案
     */
    public void subject1(String answer) {

        System.out.println("1)在Java中,如果父类中的某些方法不包含任何逻辑,并且需要有子类重写,应该使用()关键字来申明父类的这些方法。"
                + "a) Final "
                + "b) Static "
                + "c) Abstract "
                + "d) Void"
                + "");

        System.out.println("答案是:" + answer);

    }

    /**
     * 题目二
     * @param answer 传入参数为答案
     */
    public void subject2(String answer) {

        System.out.println("2) 在java中,以定义了两个接口B和C,要定义一个实现这两个接口的类,以下语句正确的是()"
                + "a) interface A extends B,C  "
                + "b) interface A implements B,C  "
                + "c) class A implements B,C"
                + "d) class A implements B,implements C "
                + "");

        System.out.println("答案是:" + answer);

    }

    /**
     * 题目三
     * @param answer 传入参数为答案
     */
    public void subject3(String answer) {

        System.out.println("3) 在java中,在定义类时加上修饰符()可以实现该类不能在本类被实例化。"
                + "a) Final  "
                + "b) Public  "
                + "c) c) Private "
                + "d) Abstract "
                + "");

        System.out.println("答案是:" + answer);

    }

}

晓明同学B:

/**
 * 同学B
 * @author Liudeli
 */
public class StudentB {

    /**
     * 题目一
     * @param answer 传入参数为答案
     */
    public void subject1(String answer) {

        System.out.println("1)在Java中,如果父类中的某些方法不包含任何逻辑,并且需要有子类重写,应该使用()关键字来申明父类的这些方法。"
                + "a) Final "
                + "b) Static "
                + "c) Abstract "
                + "d) Void"
                + "");

        System.out.println("答案是:" + answer);

    }

    /**
     * 题目二
     * @param answer 传入参数为答案
     */
    public void subject2(String answer) {

        System.out.println("2) 在java中,以定义了两个接口B和C,要定义一个实现这两个接口的类,以下语句正确的是()"
                + "a) interface A extends B,C  "
                + "b) interface A implements B,C  "
                + "c) class A implements B,C"
                + "d) class A implements B,implements C "
                + "");

        System.out.println("答案是:" + answer);

    }

    /**
     * 题目三
     * @param answer 传入参数为答案
     */
    public void subject3(String answer) {

        System.out.println("3) 在java中,在定义类时加上修饰符()可以实现该类不能在本类被实例化。"
                + "a) Final  "
                + "b) Public  "
                + "c) Private "
                + "d) Abstract "
                + "");

        System.out.println("答案是:" + answer);

    }

}

考试的很多同学回答(举例三个,其他省略….)

/**
 * 测试程序
 * @author Liudeli
 */

public class MainClass {

    public static void main(String[] args) {

        // 晓明抄了三个题目 而且在考试的那天回答完成...
        XiaoMing xiaoMing = new XiaoMing();
        xiaoMing.subject1("a");
        xiaoMing.subject2("d");
        xiaoMing.subject3("b");

        // 晓明的同学A抄了三个题目 而且在考试的那天回答完成...
        StudentA  studentA= new StudentA();
        studentA.subject1("c");
        studentA.subject2("b");
        studentA.subject3("c");

        // 晓明抄了三个题目 而且在考试的那天回答完成...
        StudentB studentB = new StudentB();
        studentB.subject1("c");
        studentB.subject2("a");
        studentB.subject3("d");

    }

}

运行结果:
技术分享



  • 我们现在跳出晓明在小山村上学的故事…,直接回到编程中来分析:
    以上的这种写法有很多的问题,晓明/晓明同学A/晓明同学B
    省略 …..
    抄黑板上面的题目是一模一样的,那么多同学一旦有人把题目抄错了,会造成很多麻烦,而且要抄那么多次,
    做了很多重复的事情,而且扩展性不好,维护性也不好,所以我们应该把,这么多同学抄写相同题目给抽取出来

定义父类方法模版:

/**
 * 定义一个题目类,把所有的题目给抽取出来,公共出来
 * @author Liudeli
 */
public class Subject {

    /**
     * 题目一
     * @param answer 传入参数为答案
     */
    public void subject1(String answer) {

        System.out.println("1)在Java中,如果父类中的某些方法不包含任何逻辑,并且需要有子类重写,应该使用()关键字来申明父类的这些方法。"
                + "a) Final "
                + "b) Static "
                + "c) Abstract "
                + "d) Void"
                + "");

        System.out.println("答案是:" + answer);

    }

    /**
     * 题目二
     * @param answer 传入参数为答案
     */
    public void subject2(String answer) {

        System.out.println("2) 在java中,以定义了两个接口B和C,要定义一个实现这两个接口的类,以下语句正确的是()"
                + "a) interface A extends B,C  "
                + "b) interface A implements B,C  "
                + "c) class A implements B,C"
                + "d) class A implements B,implements C "
                + "");

        System.out.println("答案是:" + answer);

    }

    /**
     * 题目三
     * @param answer 传入参数为答案
     */
    public void subject3(String answer) {

        System.out.println("3) 在java中,在定义类时加上修饰符()可以实现该类不能在本类被实例化。"
                + "a) Final  "
                + "b) Public  "
                + "c) Private "
                + "d) Abstract "
                + "");

        System.out.println("答案是:" + answer);

    }

}

晓明:

/**
 * 用此类模拟晓明
 * @author Liudeli
 */

public class XiaoMing extends Subject{

    /**
     * 题目一
     * @param answer 传入参数为答案
     */
    public void subject1(String answer) {
        subject1(answer);
    }

    /**
     * 题目二
     * @param answer 传入参数为答案
     */
    public void subject2(String answer) {
        subject2(answer);
    }

    /**
     * 题目三
     * @param answer 传入参数为答案
     */
    public void subject3(String answer) {
        subject3(answer);
    }

}

晓明同学A:

/**
 * 同学A
 * @author Liudeli
 */
public class StudentA extends Subject{

    /**
     * 题目一
     * @param answer 传入参数为答案
     */
    public void subject1(String answer) {
        subject1(answer);
    }

    /**
     * 题目二
     * @param answer 传入参数为答案
     */
    public void subject2(String answer) {
        subject2(answer);
    }

    /**
     * 题目三
     * @param answer 传入参数为答案
     */
    public void subject3(String answer) {
        subject3(answer);
    }

}

晓明同学B:

/**
 * 同学B
 * @author Liudeli
 */
public class StudentB extends Subject{

    /**
     * 题目一
     * @param answer 传入参数为答案
     */
    public void subject1(String answer) {
        subject1(answer);
    }

    /**
     * 题目二
     * @param answer 传入参数为答案
     */
    public void subject2(String answer) {
        subject2(answer);
    }

    /**
     * 题目三
     * @param answer 传入参数为答案
     */
    public void subject3(String answer) {
        subject3(answer);
    }

}

测试程序:

/**
 * 测试程序
 * @author Liudeli
 */
public class Main {

    public static void main(String[] args) {

        Subject xiaoMing = new XiaoMing();
        xiaoMing.subject1("c");
        xiaoMing.subject2("c");
        xiaoMing.subject3("d");

        Subject studentA = new StudentA();
        studentA.subject1("a");
        studentA.subject2("b");
        studentA.subject3("c");

        Subject studentB = new StudentB();
        studentB.subject1("c");
        studentB.subject2("b");
        studentB.subject3("c");

    }

}

运行结果
技术分享



从晓明同学类系列中分析,他们还有很多重复的区域,例如:方法重复,所以我们需要一个父类模版
把唯一在变的在子类中完成把重复的全部都在父类中完成**

查看重复项(晓明类,同学A,同学B…..,他们方法(subject1(), subject2(), subject3())都一模一样,唯一不一样的就是答案,继承的体现要继承的够彻底, 所以要抽取代码):
技术分享


父类抽取唯一改变点给子类去完成:


/**
 * 定义一个题目类,把所有的题目给抽取出来,公共出来
 * @author Liudeli
 */
public abstract class Subject {

    /**
     * 题目一
     * @param answer 传入参数为答案
     */
    public void subject1() {

        System.out.println("1)在Java中,如果父类中的某些方法不包含任何逻辑,并且需要有子类重写,应该使用()关键字来申明父类的这些方法。"
                + "a) Final "
                + "b) Static "
                + "c) Abstract "
                + "d) Void"
                + "");

        System.out.println("答案是:" + answerMethod1()); // 注意:这里只需子类去完成,只需学习回答答案即可

    }

    /**
     * 题目二
     * @param answer 传入参数为答案
     */
    public void subject2() {

        System.out.println("2) 在java中,以定义了两个接口B和C,要定义一个实现这两个接口的类,以下语句正确的是()"
                + "a) interface A extends B,C  "
                + "b) interface A implements B,C  "
                + "c) class A implements B,C"
                + "d) class A implements B,implements C "
                + "");

        System.out.println("答案是:" + answerMethod2()); // 注意:这里只需子类去完成,只需学习回答答案即可

    }

    /**
     * 题目三
     * @param answer 传入参数为答案
     */
    public void subject3() {

        System.out.println("3) 在java中,在定义类时加上修饰符()可以实现该类不能在本类被实例化。"
                + "a) Final  "
                + "b) Public  "
                + "c) Private "
                + "d) Abstract "
                + "");

        System.out.println("答案是:" + answerMethod3()); // 注意:这里只需子类去完成,只需学习回答答案即可

    }

    /**
     * 定义答案抽象方法,第一个题目的答案
     * @return 返回答案
     */
    public abstract String answerMethod1();

    /**
     * 定义答案抽象方法,第二个题目的答案
     * @return 返回答案
     */
    public abstract String answerMethod2();

    /**
     * 定义答案抽象方法,第三个题目的答案
     * @return 返回答案
     */
    public abstract String answerMethod3();

}

晓明类:

/**
 * 用此类模拟晓明
 * @author Liudeli
 */

public class XiaoMing extends Subject{

    /*
       晓明的目的就是填答案,只负责自己的职责,这也是单一职责原则的体现,
       其他的试卷制作过程,题目怎么制造出来,根本不需要去关心
    */
    public String answerMethod1() {return "a";}

    public String answerMethod2() {return "c";}

    public String answerMethod3() {return "b";}

}

晓明同学A类:

/**
 * 同学A
 * @author Liudeli
 */
public class StudentA extends Subject{

    /*
        晓明的同学A的目的就是填答案,只负责自己的职责,这也是单一职责原则的体现,
        其他的试卷制作过程,题目怎么制造出来,根本不需要去关心
    */
    public String answerMethod1() {return "c";}

    public String answerMethod2() {return "c";}

    public String answerMethod3() {return "a";}

}

晓明同学B类:

/**
 * 同学B
 * @author Liudeli
 */
public class StudentB extends Subject{

    /*
        晓明的同学A的目的就是填答案,只负责自己的职责,这也是单一职责原则的体现,
        其他的试卷制作过程,题目怎么制造出来,根本不需要去关心
    */
    public String answerMethod1() {return "c";}

    public String answerMethod2() {return "c";}

    public String answerMethod3() {return "a";}


}



案例二:
狗,鸡,猫 他们都有 叫的行为,可以这样来实现:

/**
 * 定义一个猫类
 * @author Liudeli
 */
public class Cat {

    /**
     * 猫的叫方法
     */
    public void call() {
        System.out.println("喵喵喵!!!");
    }

}

/**
 * 定义一个鸡类
 * @author Liudeli
 */
public class Chicken {

    /**
     * 鸡的叫方法
     */
    public void call() {
        System.out.println("咯咯咯!!!");
    }

}

/**
 * 定义一个狗类
 * @author Liudeli
 */
public class Dog {

    /**
     * 狗的叫方法
     */
    public void call() {
        System.out.println("汪汪汪!!!");
    }

}

/**
 * 测试程序
 * @author Liudeli
 */
public class Main {

    public static void main(String[] args) {
        // 狗,鸡,猫 他们都有 叫的行为,可以这样来实现

        Dog dog = new Dog();
        dog.call();

        Cat cat = new Cat();
        cat.call();

        Chicken chicken = new Chicken();
        chicken.call();

    }

}

运行结果:
技术分享


父类抽取相同项,模版方法方式实现:
狗,鸡,猫 他们都有 叫的行为,而他们的行为相同,都是叫,所以可以把相同的行为抽取出来定义父类模版,
* 这就是方法模版模式了,把唯一不同需要变化的交给子类去做..

/**
 * 定义一个动物类,抽取共用的行为,定义成模版
 * @author Liudeli
 */
public abstract class Animal {

    /**
     * 动物的叫方法
     */
    public void call() {
        System.out.println(callValue());
    }

    /**
     * 叫声是动物唯一不同的,所以这个是具体动物需要变换的值
     * 定义抽象 叫声
     * @return 返回叫声
     */
    public abstract String callValue();

}

/**
 * 定义一个猫类
 * @author Liudeli
 */
public class Cat extends Animal{

    /**
     * 猫的叫声
     */
    public String callValue() {
        return "喵喵喵!!!";
    }

}

/**
 * 定义一个鸡类
 * @author Liudeli
 */
public class Chicken extends Animal{

    /**
     * 鸡的叫声
     */
    public String callValue() {
        return "咯咯咯!!!";
    }

}

/**
 * 定义一个狗类
 * @author Liudeli
 */
public class Dog extends Animal{

    /**
     * 狗的叫声
     */
    public String callValue() {
        return "汪汪汪!!!";
    }

}

/**
 * 测试程序
 * @author Liudeli
 */
public class Main {

    public static void main(String[] args) {

        Animal dog = new Dog();
        dog.call();

        Animal cat = new Cat();
        cat.call();

        Animal chicken = new Chicken();
        chicken.call();

    }

}

运行结果:
技术分享




案例三:
我们来简单模拟 Android Activity 执行过程,一个应用App有很多的Activity,登录,注册,主界面
省略…
这些界面中,都有返回操作,隐藏标题栏操作,等等,都把这些共同点抽取到父类模块

错误写法:

/**
 * 简单的模拟Android中的Activity
 * @author Liudeli
 */
public class Activity {

    /**
     * 模拟Android中的 onCreate()方法
     */
    public void onCreate() {

    }

    /**
     * 模拟Android中的 onDestroy()方法
     */
    public void onDestroy() {

    }

}

/**
 * 模拟Activity中的登录操作
 * @author Liudeli
 */
public class LoginActivity extends Activity {

    /**
     * 模拟登录中的 onCreate()方法
     */
    public void onCreate() {
        System.out.println("onCreate()...");
    }

    /**
     * 模拟登录中的 onDestroy()方法
     */
    public void onDestroy() {
        System.out.println("onDestory()...");
    }

    /**
     * 模拟返回
     */
    public void back() {
        System.out.println("登录界面返回操作...");
    }

    /**
     * 隐藏标题栏
     */
    public void hideTitle() {
        System.out.println("登录界面隐藏标题栏操作...");
    }
}

/**
 * 模拟Activity中的主界面操作
 * @author Liudeli
 */
public class MainActivity extends Activity {

    /**
     * 模拟主界面中的 onCreate()方法
     */
    public void onCreate() {
        System.out.println("onCreate()...");
    }

    /**
     * 模拟主界面中的 onDestroy()方法
     */
    public void onDestroy() {
        System.out.println("onDestory()...");
    }

    /**
     * 模拟返回
     */
    public void back() {
        System.out.println("主界面返回操作...");
    }

    /**
     * 隐藏标题栏
     */
    public void hideTitle() {
        System.out.println("主界面隐藏标题栏操作...");
    }

}

/**
 * 模拟Activity中的注册操作
 * @author Liudeli
 */
public class RegisterActivity extends Activity {

    /**
     * 模拟注册中的 onCreate()方法
     */
    public void onCreate() {
        System.out.println("onCreate()...");
    }

    /**
     * 模拟注册中的 onDestroy()方法
     */
    public void onDestroy() {
        System.out.println("onDestory()...");
    }

    /**
     * 模拟返回
     */
    public void back() {
        System.out.println("注册界面返回操作...");
    }

    /**
     * 隐藏标题栏
     */
    public void hideTitle() {
        System.out.println("注册界面隐藏标题栏操作...");
    }

}

提炼代码:

/**
 * 简单的模拟Android中的Activity
 * @author Liudeli
 */
public class Activity {

    /**
     * 模拟Android中的 onCreate()方法
     */
    public void onCreate() {

    }

    /**
     * 模拟Android中的 onDestroy()方法
     */
    public void onDestroy() {

    }

}

/**
 * 抽取共用的行为
 * @author Liudeli
 */
public class BaseActivity extends Activity{

    /**
     * 模拟返回
     */
    public void back() {
        System.out.println("界面返回操作...");
    }

    /**
     * 隐藏标题栏
     */
    public void hideTitle() {
        System.out.println("界面隐藏标题栏操作...");
    }

}

/**
 * 模拟Activity中的登录操作
 * @author Liudeli
 */
public class LoginActivity extends BaseActivity {

    /**
     * 模拟登录中的 onCreate()方法
     */
    public void onCreate() {
        // 在某种业务情况下,隐藏标题栏
        if (true) {
            hideTitle();
        }
        System.out.println("onCreate()...");
    }

    /**
     * 模拟登录中的 onDestroy()方法
     */
    public void onDestroy() {
        // 在某种业务情况下,隐藏标题栏
        if (true) {
            back();
        }
        System.out.println("onDestory()...");
    }

}

/**
 * 模拟Activity中的主界面操作
 * @author Liudeli
 */
public class MainActivity extends BaseActivity {

    /**
     * 模拟主界面中的 onCreate()方法
     */
    public void onCreate() {
        // 在某种业务情况下,隐藏标题栏
        if (true) {
            hideTitle();
        }
        System.out.println("onCreate()...");
    }

    /**
     * 模拟主界面中的 onDestroy()方法
     */
    public void onDestroy() {
        // 在某种业务情况下,隐藏标题栏
        if (true) {
            back();
        }
        System.out.println("onDestory()...");
    }

}

/**
 * 模拟Activity中的注册操作
 * @author Liudeli
 */
public class RegisterActivity extends BaseActivity {

    /**
     * 模拟注册中的 onCreate()方法
     */
    public void onCreate() {
        // 在某种业务情况下,隐藏标题栏
        if (true) {
            back();
        }
        System.out.println("onCreate()...");
    }

    /**
     * 模拟注册中的 onDestroy()方法
     */
    public void onDestroy() {
        // 在某种业务情况下,隐藏标题栏
        if (true) {
            back();
        }
        System.out.println("onDestory()...");
    }   
}



案例四:
模拟:
小军在一家小型创业公司,公司开发Java的人员,就他一个人,他在实现一个功能,此功能
就是传入两个数,在传入运算符进行计算,把结果用漂亮的界面显示出来!

最近公司新招聘了一个Java工程师(小欧),不如把工作任务分担,把一些计算功能给小欧来完成,把界面显示就小军自己来完成

/**
 * 定义一个运算类
 * @author Liudeli
 */
public abstract class Operation {

    /**
     * 一个简单的方法,计算两个值,把结果用漂亮界面显示出来
     * @param number1
     * @param type
     * @param number2
     */
    public void showResultStyle(double number1, String type, double number2) {
        // 把这个计算的功能,给小欧去做
        double result = operationResult(number1, type, number2);
        // 小军值关注html 样式界面显示出来就可以了
        System.out.println("<html 这里面写了漂亮的样式....>结果是:" + result + "</html>");
    }

    /**
     * 定义一个抽象函数,此函数为计算方法,把这个计算方法给小欧去完成
     * @param number1
     * @param type
     * @param number2
     * @return
     */
    public abstract double operationResult(double number1, String type, double number2);
}

把运算功能给新来的同事小欧去做,小欧只需继承父类方法,完成子类要完成的功能即可:

/**
 * 这个类是用于计算数值
 * @author Liudeli
 */
public class Algorithm extends Operation{

    public double operationResult(double number1, String type, double number2) {
        double resultOperator = 0;
        try {
            if ("+".equals(type)) {
                resultOperator = number1 + number2;
            } else if ("-".equals(type)) {
                resultOperator = number1 - number2;
            } else if ("*".equals(type)) {
                resultOperator = number1 * number2;
            } else if ("/".equals(type)) {
                resultOperator = number1 / number2;
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("输入有误!!! e:" + e.toString());
        }
        return resultOperator;
    }

}

子类与子类多个子类都要相同的行为,应该把这些行为,用父类方法模版抽取出来,子类只完成变化点即可,这也属于开放封闭式原则,更好的维护性扩展性,同时自然也是复用性


谢谢大家的观看,更多精彩技术博客,会不断的更新,请大家访问,
刘德利CSDN博客, http://blog.csdn.net/u011967006

<script type="text/javascript"> $(function () { $(‘pre.prettyprint code‘).each(function () { var lines = $(this).text().split(‘\n‘).length; var $numbering = $(‘
    ‘).addClass(‘pre-numbering‘).hide(); $(this).addClass(‘has-numbering‘).parent().append($numbering); for (i = 1; i <= lines; i++) { $numbering.append($(‘
  • ‘).text(i)); }; $numbering.fadeIn(1700); }); }); </script>

    方法模版模式(设计模式_11)【精品博客】