Java 模板方法模式

模板方法模式：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，模板方法可以使子类可以不改变一个

算法的结构即可以重定义该算法的某些特定步骤。

 

 

方法模式的特点：把不变的行为搬到超类，去除子类中重复的代码来体现他的优势。

 

当不变的和可变的行为在方法中混合在一起时，不变的行为就会在子类中重复出现，模板方法模式就是将这些不变的

行为搬移到一个超类中，避免重复代码。

 

 

 

应用场景：需要定义一些顶级逻辑 或者是一个操作中算法的骨架，希望一些步奏的执行推迟到其子类中时 应该考虑模板模式。

   在此写了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.}