代码改变世界

设计模式之模板方法模式

2012-10-06 02:23  youxin  阅读(319)  评论(0编辑  收藏  举报

 模板方法模式,我们将要深入封装算法块,好让子类可以在任何时候都可以将自己挂接进运算里。

茶和咖啡的冲泡方式非常相似,不信你瞧瞧:

快速搞定几个咖啡和茶的类。

public class Coffee {
 
    void prepareRecipe() {
        boilWater();
        brewCoffeeGrinds();
        pourInCup();
        addSugarAndMilk();
    }
 
    public void boilWater() {
        System.out.println("Boiling water");
    }
 
    public void brewCoffeeGrinds() {
        System.out.println("Dripping Coffee through filter");
    }
 
    public void pourInCup() {
        System.out.println("Pouring into cup");
    }
 
    public void addSugarAndMilk() {
        System.out.println("Adding Sugar and Milk");
    }
}

接下来是茶:

public class Tea {
 
    void prepareRecipe() {
        boilWater();
        steepTeaBag();
        pourInCup();
        addLemon();
    }
 
    public void boilWater() {
        System.out.println("Boiling water");
    }
 
    public void steepTeaBag() {
        System.out.println("Steeping the tea");
    }
 
    public void addLemon() {
        System.out.println("Adding Lemon");
    }
 
    public void pourInCup() {
        System.out.println("Pouring into cup");
    }
}

 

可以看到,我们发现了重复的代码,需要清理下设计了。

我们可能想要设计一个基类,新的类层次如下:

 

更进一步的设计

星巴克咖啡冲泡法

1.把水煮沸

2.用沸水冲泡咖啡

3.把咖啡 倒进杯子

4.加糖和牛奶

星巴克茶冲泡法

1.把水煮沸

2.用沸水浸泡茶叶

3把茶倒进杯子

4加柠檬

注意2份冲泡法都采用了相同的算法:

1.把水煮沸

3.用热水泡咖啡或茶

3.把饮料倒进杯子

4在饮料内加入适当的调料

抽象prepareRecipe()

  让我们从每一个子类(也就是茶和咖啡)中逐步抽象prepareRecipe()。。

1.所遇到的 第一个问题,就是咖啡使用brewCoffeeGrinds()和addSugarAndMilk()方法,而茶

使用的是steepTeaBag)(和addLemon()方法。

 让我们来思考这一点:浸泡steep和冲泡brew差异其实不多。所以我们给他一个新的方法名称,比方说brew(),然后不管是泡茶或是冲泡咖啡我们都用这个名称。类似地,加糖和牛奶很相似:都是在饮料中加入调料。我们也用一个新的方法名称来解决:叫做addCondiments()好了。这样一来,新的prepareRecipe()看起来像这样

void prepareRecipe()

{

   boilWater();

  brew();

  pourInCup();

addCondiments();

}

 2.现在,我们有了新的prepareRecipe()方法,但是需要让它能符合代码,我们先从超类开始:

3最后,我们出来子类。子类依赖超类。

 

现在我们已经将prepareRecipe()的实现放在超类中了。

认识模板方法

  基本 上,我们刚做的就是模板方法模式。这是什么?让我们看看咖啡因饮料类的结果,它包含了实际的“模板方法”。

注意,上面的有个小错误,final应放在void的前面,否则报错

 

prepareRecipe()是我们的模板方法。为什么?》

因为:

1.毕竟他是一个方法

2.它用作一个算法的模板,在这个例子中,算法是用来制作咖啡因饮料的。 

 在这个模板中,算法内的每一个步骤都被一个方法代表了。

某些方法是有这个类(超类)处理的。某些是由子类处理的。需要由子类提供的方法,必须在超类中声明为抽象。

模板方法定义了一个算法的步骤,并允许子类为一个或多个步骤提供实现

 

走,泡茶去。。。

 让我们逐步地泡茶,追踪这个模板方法是如何工作的。你会得知在算法内的某些地方,该模板方法控制了算法。它让子类能够提供某些步骤的实现。。。

 

模板方法给我们带来了什么?

 

上面的图值得细看。

定义模板方法模式

  模板方法模式:在一个方法中定义一个算法的骨架,而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下,重新定义算法中的某些步骤

 这个模式是用来创建一个算法的模板。什么是模板?如你所见,模板就是一个方法。更具体的说,这个方法将算法定义成一组步骤,其中的任何步骤都可以是抽象的,由子类实现。这可以确保算法的结构保持不变,同时由子类提供部分实现

让我们看看类图:

 

让我们细看抽象类是如何被定义的,包括了它内含的模板方法和原语操作。

让我们再靠近一点,详细看看抽象类可以有哪些类型的方法:

 

对模板方法进行挂钩

 钩子hook是一种被声明在抽象类中的方法,但是只有空的或者默认的实现。钩子的存在,可以让子类有能力对算法的不同点进行挂钩。要不要挂钩,由子类自行决定

钩子有好几种用途,让我们先看其中一个:

上面的customerWantsCondiments()就是一个钩子,子类可以覆盖这个方法,但不一定要覆盖

使用钩子

 为了使用钩子,我们在子类中覆盖它。在这里,钩子控制了咖啡因饮料是否执行某部分的算法,说的更明确一些,就是饮料中是否要加调料。

 我们如何得知顾客是否想要调料呢?开口问不就知道了。

public class CoffeeWithHook extends CaffeineBeverage{

            void brew() {
                // TODO Auto-generated method stub
                System.out.println("Dripping Coffee through filter");
            }

            void addCondiments() {
                // TODO Auto-generated method stub
                System.out.println("Adding Sugar and Milk");
            }
            
            public boolean customerWantsCondiments(){
                String answer=getUserInput();
                if(answer.toLowerCase().startsWith("y"))
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            private String getUserInput()
            {
                String answer=null;
                System.out.println("would you like milk and sugar with your coffee (y/n");
                BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
                try {
                    answer=in.readLine();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                if(answer==null)
                {
                    return "no";
                    
                }
                return answer;
            }
}

执行测试程序:

public class TestMain {
    public static void main(String[] args)
    {
     
        CoffeeWithHook coffeeWithHook=new CoffeeWithHook();
         
        coffeeWithHook.prepareRecipe();
    }

}

这个例子实在太酷了,使用钩子能够作为条件控制,影响抽象类中的算法流程。

问:当我创建一个模板方法时,怎么才能知道什么时候使用抽象方法,什么时候使用钩子?

 答:当你的子类“必须”提供算法中的某个方法或步骤的实现时,就是要抽象方法。如果算法的这个部分是可选的,就用钩子。如果是钩子的话,子类可以选择实现这个钩子 ,但并不强制这么做。

 

好莱坞原则:don't call me ,i'll call you!.

好莱坞原则可以给我们一种防止“依赖腐败”dependency rot的方法。当高层组件依赖低层组件,而低层组件又依赖高层组件,而高层组件又依赖边侧组件,而边侧组件又依赖低层组件时,依赖腐败就发生了。这种情况下,没有人可以轻易搞懂系统是如何设计的。

在好莱坞原则之下,我们允许低层组件自己挂钩到系统上,但是高层组件会决定什么时候和怎样使用这些低层组件。换句话说,高层组件对低层组件的方式是“别调用我们,我们会调用你”。

好莱坞原则和模板方法

  当我们设计模板方法模式时,我们告诉子类,“不要调用我们,我们会调用你”。怎样才能办到呢?让我们看看设计:

还有工厂方法和观察者模式都采用了这个原则

问:低层组件不可以调用高层组件中的方法呢?

答:并不尽然。事实上,低层组件在结束时,常常会调用从超类中继承来的方法。我们要做的是,避免让高层组件和低层组件之间有明显的环状依赖

 

荒野中的模板方法

 模板方法模式是一个很常见的模式,到处都是。尽管如此,你必须拥有一双锐利的眼睛,因为模板 方法有许多实现

这个模式很常见是因为对创建框架来说,这个模式简直棒极了。由框架控制如何做事情,而由你(使用这个框架的人)
指定框架算法中每个步骤的细节。

让我们步入荒野,展开狩猎把!(好吧!荒野就是指java api)。。。

 

写一个Swing的窗口程序
 JFrame有一个paint()方法,在默认状态下,paint()是不做明显的事情的,因为他是一个“钩子”!通过覆盖paint(),你可以将自己的代码插入JFrame的算法中,显示出你想要的画面。下面是一个简单的例子。

public class MyFrame extends JFrame{
    public MyFrame(String title)
    {
        super(title);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        
        this.setSize(300,300);
        this.setVisible(true);
    }
    
    public void paint(Graphics graphics)
    {
        super.paint(graphics);
        String msg="I rule!";
        graphics.drawString(msg,100,100);
    }
    
    public static void main(String[] args)
    {
        new MyFrame("hello");
    }

}

 

要点:


为了防止子类改变模板方法中的算法,可以将模板方法声明为final

好莱坞原则告诉我们,将决策权放在高层模块中,以便决定如何以及何时调用低层组件

策略模式和模板方法模式都封装算法,一个用组合,一个用继承

工厂方法是模板方法的一种特殊版本。