设计模式-模板方法模式

模板方法

关注公众号 JavaStorm 获取更多精彩。

模板方法模式在一个方法中定义了一个算法骨架，并且 final 修饰防止子类重写。方法中包含一些抽象方法，也就是一些步骤延迟到字类实现。模板方法使得在不改变算法结构的情况下，重新定义算法中的某些步骤。完整代码可以查看GitHub：https://github.com/UniqueDong/zero-design-stu

类图

模式实现

在实现模板方法模式时，开发抽象类的软件设计师和开发具体子类的软件设计师之间可以进行协作。一个设计师负责给出一个算法的轮廓和框架，另一些设 计师则负责给出这个算法的各个逻辑步骤。实现这些具体逻辑步骤的方法即为基本方法，而将这些基本方法汇总起来的方法即为模板方法，模板方法模式的 名字也因此而来。下面将详细介绍模板方法和基本方法：

1. 模板方法 一个模板方法是定义在抽象类中的、把基本操作方法组合在一起形成一个总算法或一个总行为的方法。这个模板方法定义在抽象类中，并由子类不加以修改 地完全继承下来。模板方法是一个具体方法，它给出了一个顶层逻辑框架，而逻辑的组成步骤在抽象类中可以是具体方法，也可以是抽象方法。由于模板方法 是具体方法，因此模板方法模式中的抽象层只能是抽象类，而不是接口。

2. 基本方法 基本方法是实现算法各个步骤的方法，是模板方法的组成部分。基本方法又可以分为三种：抽象方法(Abstract Method)、具体方法(Concrete Method)和钩子方法(Hook Method)。

   (1) 抽象方法：一个抽象方法由抽象类声明、由其具体子类实现。

   (2) 具体方法：一个具体方法由一个抽象类或具体类声明并实现，其子类可以进行覆盖也可以直接继承。

   (3) 钩子方法：一个钩子方法由一个抽象类或具体类声明并实现，而其子类可能会加以扩展。通常在父类中给出的实现是一个空实现，并以该空实 现作为方法的默认实现，当然钩子方法也可以提供一个非空的默认实现。 钩子可以让子类实现算法中可选的部分，或者在钩子对于子类的实现并不重要的时候，子类可以对此钩子置之不理。钩子的另一个用法，是让子类能够有机会 对模板方法中某些即将发生的（或刚刚发生的）步骤做出反应。

使用场景

开一家咖啡、茶馆，泡茶和咖啡的冲泡方式非常相似：

星巴克咖啡冲泡法

1. 把水煮沸

2. 用沸水冲泡咖啡

3. 把咖啡倒进杯子

4. 加糖和牛奶

功夫茶冲泡法

1. 把水煮沸

2. 用沸水冲泡茶叶

3. 把茶倒进杯子

4. 加柠檬

我们可以发现两种茶的步骤1，和步骤3是一样的。整体算法结构是固定的，只是有的部分不一样。这时候我们就可以使用模板方法设计模式定义制作骨架，然后部分细节留给子类实现。

代码实现

首先我们先抽象一个制作饮料的模板，定义算法逻辑 AbstractBeverage。同时有一个钩子方法，一般是空实现，在这里我们可以通过它（customerWantsCondiments()）来控制是否加调料。

1. package com.zero.design.actions.template;

2. /**

3. * 抽象制作饮料模板:定义算法骨架

4. */

5. public abstract class AbstractBeverage {

6. /**

7. * 这就是模板方法。它被声明为final，以免子类改变这个算法的顺序。

8. * 算法步骤组合

9. */

10. final void prepareRecipe() {

11. // 模板方法定义了一连串的步骤，每个步骤由一个方法代表

12. boilWater();

13. brew();

14. pourInCup();

15. if (customerWantsCondiments()) {

16. addCondiments();

17. }

18. }

19. /**

20. * 我们在这里定义了一个方法，（通常）是空的缺省实现。这个方法只会返回true，不做别的事。

21. * 这就是一个钩子，子类可以覆盖这个方法，但不见得一定要这么。

22. * @return

23. */

24. boolean customerWantsCondiments() {

25. return true;

26. }

27. /**

28. * 添加佐料:不同饮料也有不同佐料：申明为抽象类，由子类取操心

29. */

30. protected abstract void addCondiments();

31. /**

32. * 酿制:不同饮料方式也不同，申明为抽象类，由子类取操心

33. */

34. protected abstract void brew();

35. /**

36. * 共通方法:倒入杯中

37. */

38. public void pourInCup() {

39. System.out.println("倒入杯子中...");

40. }

41. /**

42. * 把水煮沸,共通方法

43. */

44. public void boilWater() {

45. System.out.println("把水煮沸...");

46. }

47. }

接着我们定义泡茶具体算法，并且继承 AbstractBeverage 抽象算法，实现泡茶的具体逻辑。

1. package com.zero.design.actions.template;

2. public class Tea extends AbstractBeverage {

3. /**

4. * 这样通过钩子就可以选择是都要加佐料了

5. */

6. private boolean addCondiments = true;

7. /**

8. * 添加糖、牛奶

9. */

10. @Override

11. protected void addCondiments() {

12. System.out.println("添加柠檬，茶更好喝");

13. }

14. /**

15. * 咖啡冲泡方法

16. */

17. @Override

18. protected void brew() {

19. System.out.println("秘制泡茶方式放入茶叶");

20. }

21. /**

22. * 使用钩子，不加佐料

23. * @return

24. */

25. @Override

26. boolean customerWantsCondiments() {

27. return addCondiments;

28. }

29. public boolean isAddCondiments() {

30. return addCondiments;

31. }

32. public void setAddCondiments(boolean addCondiments) {

33. this.addCondiments = addCondiments;

34. }

35. }

定义咖啡的算法细节

1. package com.zero.design.actions.template;

2. /**

3. * 咖啡具体实现：只需要自行处理冲泡和添加调料部分

4. */

5. public class Coffe extends AbstractBeverage {

6. /**

7. * 这样通过钩子就可以选择是都要加佐料了

8. */

9. public boolean addCondiments = true;

10. /**

11. * 添加糖、牛奶

12. */

13. @Override

14. protected void addCondiments() {

15. System.out.println("添加糖跟牛奶");

16. }

17. /**

18. * 咖啡冲泡方法

19. */

20. @Override

21. protected void brew() {

22. System.out.println("放入咖啡豆，使用秘制方法冲泡");

23. }

24. /**

25. * 重写钩子

26. * @return

27. */

28. @Override

29. boolean customerWantsCondiments() {

30. return addCondiments;

31. }

32. public boolean isAddCondiments() {

33. return addCondiments;

34. }

35. public void setAddCondiments(boolean addCondiments) {

36. this.addCondiments = addCondiments;

37. }

38. }

接着就是客户点单，我们通过模板方法模式制作咖啡或者功夫茶。达到代码复用。

1. package com.zero.design.actions.template;

2. /**

3. * Created by unique on 2017/6/7.

4. */

5. public class Test {

6. public static void main(String[] args) {

7. Tea tea = new Tea();

8. tea.setAddCondiments(false);

9. tea.prepareRecipe();

10. System.out.println("-------------------");

11. Coffe coffe = new Coffe();

12. coffe.prepareRecipe();

13. }

14. }

输出如下

1. 把水煮沸...

2. 秘制泡茶方式放入茶叶

3. 倒入杯子中...

4. -------------------

5. 把水煮沸...

6. 放入咖啡豆，使用秘制方法冲泡

7. 倒入杯子中...

8. 添加糖跟牛奶

模板方法模式的优缺点

优点

1）良好的封装性。把公有的不变的方法封装在父类，而子类负责实现具体逻辑。

2）良好的扩展性：增加功能由子类实现基本方法扩展，符合单一职责原则和开闭原则。

3）复用代码。

缺点

1）由于是通过继承实现代码复用来改变算法，灵活度会降低。

2）子类的执行影响父类的结果，增加代码阅读难度。

点赞与收藏是最大的鼓励。欢迎关注公众号 JavaStorm