模板方法模式:定义一个操作中的算法的骨架,而将一些步骤延迟到子类中,模板方法可以使子类可以不改变一个
算法的结构即可以重定义该算法的某些特定步骤。
方法模式的特点:把不变的行为搬到超类,去除子类中重复的代码来体现他的优势。
当不变的和可变的行为在方法中混合在一起时,不变的行为就会在子类中重复出现,模板方法模式就是将这些不变的
行为搬移到一个超类中,避免重复代码。
应用场景:需要定义一些顶级逻辑 或者是一个操作中算法的骨架,希望一些步奏的执行推迟到其子类中时 应该考虑模板模式。
在此写了3个java类来描述说明Templete设计模式;
1、Templete.java 定义了顶级逻辑的抽象类
2、TempleteImpl.java 实现了抽象类中抽象方法的子类
3、TempletTest.java 带有main方法的测试类
[java] view plaincopy
01.=============== 1、Templete.java
02.package templete;
03.public abstract class Templete {
04. //顶级逻辑
05. public void topOperation(){
06. //1
07. beforeOperation();
08.
09. //2
10. operation();
11.
12. //3
13. afterOperation();
14. }
15.
16. //需要在操作前执行的方法
17. private void beforeOperation(){
18. System.out.println("This acton before the operation!");
19. }
20.
21. //需要在操作后执行的方法
22. private void afterOperation(){
23. System.out.println("This acton after the operation!");
24. }
25.
26. //需要推迟到子类(实现类) 中执行
27. protected abstract void operation();
28.}
29.=============== 1 end
30.
31.=============== 2、TempleteImpl.java
32.package templete;
33.public class TempleteImpl extends Templete {
34. @Override
35. protected void operation() {
36. // TODO Auto-generated method stub
37. System.out.println("The operation action is executed in the method of ServiceA instance! ");
38. }
39.}
40.=============== 2 end
41.
42.=============== 3、TempletTest.java
43.package templete;
44.public class TempletTest {
45. public static void main(String[] args) {
46. Templete templete = new TempleteImpl();
47. templete.topOperation();
48. }
49.}
50.=============== 3 end
[java] view plaincopy
01.//模板模式,将通用的抽象到父类,将个别不同的处理交由继承的子类实现
02.//父类就是模板。
03./**
04. * 当我们要完成某一细节层次一致的一个过程或者一系列的步骤,但是某个个别步骤在更详细
05. * 的层次上的实现可能不同时,我们通常考虑用模板方法模式来处理
06. */
07.abstract class Mould {
08.
09. public static void main(String[] args) {
10. Mould A = new ConcreteA();
11. A.testMain();
12. Mould B = new ConcreteB();
13. B.testMain();
14.
15. }
16.
17. //不同的步骤交由不同的子类实现。
18. public abstract void printOperaction1();
19. public abstract void printOperaction2();
20.
21.
22. //相同的处理步骤
23. public void testMain(){
24. printOperaction1();
25. printOperaction2();
26. }
27.}
28./**
29. *每个模板可以有多个不同的子类与之对应。
30. *每一个实现类都给出抽象方法的具体实现。
31. */
32.//继承模板类,实现个性化步骤
33.class ConcreteA extends Mould{
34. @Override
35. public void printOperaction1() {
36. System.out.println("I'm concreteA operaction1");
37. }
38. @Override
39. public void printOperaction2() {
40. System.out.println("I'm concreteA operaction2");
41. }
42.}
43.//继承模板类,实现个性化步骤
44.class ConcreteB extends Mould{
45. @Override
46. public void printOperaction1() {
47. System.out.println("I'm concreteB operaction1");
48. }
49. @Override
50. public void printOperaction2() {
51. System.out.println("I'm concreteB operaction2");
52. }
53.}
Java 模板方法模式
最新推荐文章于 2024-08-10 07:45:00 发布