模板方法模式
(Template Method Pattern)在超类
中定义了
一个算法的骨架
,将一些步骤延迟到子类中实现。模板方法模式使得子类可以在不改变算法结构的情况下
,重新定义
算法的某些步骤
。
基本组成:
Abstract (抽象类):定义了模板方法和一些基本的方法。模板方法是一个定义算法骨架的方法,它调用基本方法来完成算法的各个步骤。
Concrete(具体类):继承自抽象类,实现模板方法中尚未实现的基本方法。
Hook Method(钩子方法):在抽象类中定义,可以被子类重写。钩子方法允许子类在模板方法的执行过程中进行干预。
优点
封装了算法的变化,提高了代码的复用性。
子类可以控制算法的某些步骤,而不需要改变算法的结构。
缺点
每一个不同的实现都需要一个子类,这可能会导致类的数量增加。
应用场景
当需要在一个算法中定义一系列步骤,但某些步骤可以延迟到子类中实现时。
当需要复用代码,但不希望子类依赖于特定的实现时。
示例
:Beverage 是抽象类,定义了制作饮料的模板方法和一些基本方法。Tea 和 Coffee 是具体类,它们继承自 Beverage 并重写 brew 方法。客户端通过调用 prepareRecipe 方法来制作不同的饮料。
//抽象类
public abstract class Beverage {
//模板方法
public final void perpareRecipe(){
boilwater();
brew();
pourInCup();
addCoundiments();
}
//基本方法,可以是抽象的,也可以为具体的
protected abstract void brew();
protected void addCoundiments(){
System.out.println("Adding lemon");
}
//钩子方法
protected void hood(){
System.out.println("Doing something before adding condiments");
}
//其他基本方法
private void boilwater(){
System.out.println("Boiling water");
}
private void pourInCup(){
System.out.println("Pouring into cup");
}
}
//具体类
public class Tea extends Beverage{
@Override
protected void brew() {
System.out.println("Steeping the tea");
}
public void addCondiments(){
super.addCoundiments();
System.out.println("Adding tea specific condiments");
}
}
//具体类
public class Coffee extends Beverage{
@Override
protected void brew() {
System.out.println("Dripping coffee through filter");
}
public void addCondiments(){
super.addCoundiments();
System.out.println("Adding coffee specific condiments");
}
public void hook(){
System.out.println("Doing somenthing coffee specific before adding condiments");
}
}
public class Client {
public static void main(String[] args) {
Beverage tea=new Tea();
tea.perpareRecipe();
System.out.println("----------------------------");
Beverage coffee=new Coffee();
coffee.perpareRecipe();
}
}