在講述這個模式之前，我們先看一個案例：抄題目：兩個學生將老師出的題目抄寫在紙上，并且寫出答案

先看一個比較笨的寫法

public class TestPaperA { public void testQuestion1(){ System.out.println('1+1等于幾？ a.1 b.2 c.3 d.4'); System.out.println('答案：b'); } public void testQuestion2(){ System.out.println('1*1等于幾？ a.1 b.2 c.3 d.4'); System.out.println('答案：a'); } public void testQuestion3(){ System.out.println('1/1等于幾？ a.1 b.2 c.3 d.4'); System.out.println('答案：a'); }}public class TestPaperB { public void testQuestion1(){ System.out.println('1+1等于幾？ a.1 b.2 c.3 d.4'); System.out.println('答案：c'); } public void testQuestion2(){ System.out.println('1*1等于幾？ a.1 b.2 c.3 d.4'); System.out.println('答案：a'); } public void testQuestion3(){ System.out.println('1/1等于幾？ a.1 b.2 c.3 d.4'); System.out.println('答案：d'); }}public class Test { public static void main(String[] args) { System.out.println('學生甲抄的試卷：'); TestPaperA studentA= new TestPaperA(); studentA.testQuestion1(); studentA.testQuestion2(); studentA.testQuestion3(); System.out.println('學生乙抄的試卷：'); TestPaperB studentB= new TestPaperB(); studentB.testQuestion1(); studentB.testQuestion2(); studentB.testQuestion3(); }}

輸出結果：

學生甲抄的試卷：1+1等于幾？ a.1 b.2 c.3 d.4答案：b1*1等于幾？ a.1 b.2 c.3 d.4答案：a1/1等于幾？ a.1 b.2 c.3 d.4答案：a學生乙抄的試卷：1+1等于幾？ a.1 b.2 c.3 d.4答案：c1*1等于幾？ a.1 b.2 c.3 d.4答案：a1/1等于幾？ a.1 b.2 c.3 d.4答案：d

可以看出，學生甲和學生乙除了答案不一樣，抄的題目都一樣，抄題目的過程容易出錯，而且如果老師改了題目，那么兩個學生都需要把題目改掉

怎么優化？我們先來一個初步優化：學過繼承的都會想到，把公共部分放到父類中，子類繼承父類后，自然就擁有了公共部分

public class TestPaper { public void testQuestion1(){ System.out.println('1+1等于幾？ a.1 b.2 c.3 d.4'); } public void testQuestion2(){ System.out.println('1*1等于幾？ a.1 b.2 c.3 d.4'); } public void testQuestion3(){ System.out.println('1/1等于幾？ a.1 b.2 c.3 d.4'); }}public class TestPaperA extends TestPaper{ @Override public void testQuestion1(){ super.testQuestion1(); System.out.println('答案：b'); } @Override public void testQuestion2(){ super.testQuestion2(); System.out.println('答案：a'); } @Override public void testQuestion3(){ super.testQuestion3(); System.out.println('答案：a'); }}public class TestPaperB extends TestPaper{ @Override public void testQuestion1(){ super.testQuestion1(); System.out.println('答案：c'); } @Override public void testQuestion2(){ super.testQuestion2(); System.out.println('答案：a'); } @Override public void testQuestion3(){ super.testQuestion3(); System.out.println('答案：d'); }}

測試類同上

我們看這個初步優化，發現還是有重復的部分，比如super.testQuestion1()和System.out.println('答案”)

我們既然用了繼承，并且肯定這個繼承有意義，就應該要成為子類的模板，所有重復的代碼都應該要上升到父類去，而不是讓每個子類都去重復。

對于“抄題目”這個例子來說，除了學生的答案會有不同的結果，其他全部都是一樣的。繼續優化：

public abstract class TestPaper { public void testQuestion1(){ System.out.println('1+1等于幾？ a.1 b.2 c.3 d.4'); System.out.println('答案：'+answer1()); } public void testQuestion2(){ System.out.println('1*1等于幾？ a.1 b.2 c.3 d.4'); System.out.println('答案：'+answer2()); } public void testQuestion3(){ System.out.println('1/1等于幾？ a.1 b.2 c.3 d.4'); System.out.println('答案：'+answer3()); } public abstract String answer1(); public abstract String answer2(); public abstract String answer3();}public class TestPaperA extends TestPaper{ @Override public String answer1() { return 'b'; } @Override public String answer2() { return 'a'; } @Override public String answer3() { return 'a'; }}public class TestPaperB extends TestPaper{ @Override public String answer1() { return 'c'; } @Override public String answer2() { return 'a'; } @Override public String answer3() { return 'd'; }}public class Test { public static void main(String[] args) { System.out.println('學生甲抄的試卷：'); TestPaper studentA= new TestPaperA(); studentA.testQuestion1(); studentA.testQuestion2(); studentA.testQuestion3(); System.out.println('學生乙抄的試卷：'); TestPaper studentB= new TestPaperB(); studentB.testQuestion1(); studentB.testQuestion2(); studentB.testQuestion3(); }}

輸出結果：

學生甲抄的試卷：1+1等于幾？ a.1 b.2 c.3 d.4答案：b1*1等于幾？ a.1 b.2 c.3 d.4答案：a1/1等于幾？ a.1 b.2 c.3 d.4答案：a學生乙抄的試卷：1+1等于幾？ a.1 b.2 c.3 d.4答案：c1*1等于幾？ a.1 b.2 c.3 d.4答案：a1/1等于幾？ a.1 b.2 c.3 d.4答案：d

結果和之前一模一樣，但簡潔了很多。此時要有更多的學生來答卷，只不過是在試卷的木板上填寫選擇題的選項答案，這是每個人的試卷唯一不同（誰說的，名字也不同，但這樣的做法的確是對試卷的最大復用）

下面介紹模板方法模式：https://www.jb51.net/article/189195.htm

模板方法模式：定義一個操作中的算法的骨架，而將一些步驟延遲到子類中。模板方法使得子類可以不改變一個算法的結構即可重定義該算法的某些特定步驟。

AbstractClass是抽象類，其實也就是一抽象模板，定義并實現了一個模板方法。這個模板方法一般是一個具體方法。它給出了一個頂級邏輯的骨架，而邏輯的組成步驟在相應的抽象操作中，推遲到子類實現。

public abstract class AbstractClass { //一些抽象行為，放到子類去實現 public abstract void primitiveOperation1(); public abstract void primitiveOperation2(); //模板方法，給出了邏輯的骨架，而邏輯的組成是一些相應的抽象操作，它們都推遲到子類去實現 public void templateMethod(){ primitiveOperation1(); primitiveOperation2(); }}

ConcreteClass實現父類所定義的一個或多個抽象方法。每一個AbstractClass都可以有任意多個ConcreteClass與之對應，而每一個ConcreteClass都可以給出這些抽象方法（也就是頂級邏輯的組成步驟）的不同實現，從而使得頂級邏輯的實現各不相同。

public class ConcreteClassA extends AbstractClass{ @Override public void primitiveOperation1() { //具體類A方法1實現，與ConcreteClassB不同的方法實現 } @Override public void primitiveOperation2() { //具體類A方法2實現，與ConcreteClassB不同的方法實現 }}public class ConcreteClassB extends AbstractClass{ @Override public void primitiveOperation1() { //具體類B方法1實現，與ConcreteClassA不同的方法實現 } @Override public void primitiveOperation2() { //具體類B方法2實現，與ConcreteClassA不同的方法實現 }}

測試代碼

public class Test { public static void main(String[] args) { AbstractClass c = null; c = new ConcreteClassA(); c.templateMethod(); c = new ConcreteClassB(); c.templateMethod(); }}

模板方法模式是通過把不變行為搬移到超類，去除子類中的重復代碼來體現它的優勢。

模板方法模式就是提供了一個很好的代碼復用平臺。因為有時候，我們會遇到由一系列步驟構成的過程需要執行。這個過程從高層次上看是相同的，但有些步驟的實現可能不同。這時候，我們通常就應該要考慮用模板方法模式了。

當不變的和可變的行為在方法的子類實現中混合在一起的時候，不變的行為就會在子類中重復出現。我們通過模板方法模式把這些行為搬移到單一的地方，這樣就幫助子類擺脫重復的不變行為的糾纏

以上就是實例講解JAVA 模板方法模式的詳細內容，更多關于JAVA 模板方法模式的資料請關注好吧啦網其它相關文章！