Template Pattern Pattern method

The 1> template pattern defines the steps of the algorithm, extending the implementation of these steps to subclasses

2> template mode provides us with a code reuse technique.

3> Template Abstract classes can define specific methods, abstract methods, and Hook methods

4> to prevent subclasses from changing the algorithm in the template, the template method can be declared as final

A 5> hook is a method that does not work in an abstract class, or only does the default, and subclasses can choose to implement it

Template method pattern, which defines the skeleton of an algorithm in one method, and delays some steps into subclasses. The template method allows subclasses to redefine some of the steps in the algorithm without changing the attaining of the algorithm structure.

Examples of our use of brewed coffee and brewing tea

Processing Flow:

Coffee Brewing Method: 1. Boil the water, 2. Brew coffee in boiling, 3. Pour the coffee into the cup, 4. Add sugar and milk

Tea Brewing Method: 1. Boil the water, 2. Brew the tea with boiling, 3. Pour the tea into the cup, 4. Add Honey

Practice steps:

1> Create a template (abstract) class: Beverage (beverage)

Java code

2. Package com.kaishengit.beverage;
6. Public abstract class Beverage {
8. /** 
10. * Brew coffee or tea ... Process
12. */
14. public final void Create () {
16. Boilwater (); //Boil the water
18. Brew (); //Brew with boiling water ...
20. Pourincup (); //Put ... Pour into the cup
22. Addcoundiments (); //Plus ...
24. }
30. public abstract void addcoundiments ();
34. public abstract Void Brew ();
38. public void Boilwater () {
40. System.out.println ("boiled water");
42. }
46. public void Pourincup () {
48. System.out.println ("pour into cup");
50. }
52. }

2> Create a coffee class (Coffee) and tea class, all inheriting beverage abstract class

1. Coffee (Coffee)

Java code

2. Package com.kaishengit.beverage;
6. Public class Coffee extends beverage{
10. @Override
12. public void Addcoundiments () {
14. System.out.println ("Add sugar and milk"); }  
18. @Override
20. public Void Brew () {
22. System.out.println ("Brew Coffee with water");
24. }
26. }

2. Tea (TEAS)

Java code

2. Package com.kaishengit.beverage;
6. Public class Tea extends beverage{
10. @Override
12. public void Addcoundiments () {
14. System.out.println ("Add Honey");
16. }
20. @Override
22. public Void Brew () {
24. System.out.println ("tea with water");
26. }
30. }

3. Let's test:

Java code

2. Package com.kaishengit.beverage;
6. Public class Test {
8. public static void Main (string[] args) {
10. Coffee Coffee = new Coffee ();
12. Coffee.create (); //Brew coffee
16. //tea tea = new tea ();//Brewing Tea
18. //tea.create ();
20. }
22. }

Operation Result:

-----------------------------------

Boiled boiled water

Coffee with water

Pour into the cup

Add sugar and milk

-----------------------------------

Using hooks in template mode

There is an empty implementation method, we call this method "hook". Subclasses can decide whether to overwrite it, depending on the situation.

1> we modify the template class (beverage)

Java code

2. Package com.kaishengit.beverage;
6. Public abstract class Beverage {
8. /** 
10. * Brew coffee or tea ... Process
12. */
14. public final void Create () {
16. Boilwater (); //Boil the water
18. Brew (); //Brew with boiling water ...
20. Pourincup (); //Put ... Pour into the cup
22. Addcoundiments (); //Plus ...
26. Hook (); //Hooks
28. }
30. //Null implementation method
32. public void Hook () {}
36. public abstract void addcoundiments ();
40. public abstract Void Brew ();
44. public void Boilwater () {
46. System.out.println ("boiled water");
48. }
52. public void Pourincup () {
54. System.out.println ("pour into cup");
56. }
58. }

2> if we engage in activities, drink a cup of coffee, modify the coffee (Coffee) class

Java code

2. Package com.kaishengit.beverage;
6. Public class Coffee extends beverage{
10. @Override
12. public void Addcoundiments () {
14. System.out.println ("Add sugar and milk"); }  
18. @Override
20. public Void Brew () {
22. System.out.println ("Brew Coffee with water");
24. }
28. /** 
30. * Hooks
32. */
34. @Override
36. public void Hook () {
38. System.out.println ("one more Cup");
40. }
44. }

3> using the test class above

Operation Result:

--------------------------------

Boiled boiled water

Coffee with water

Pour into the cup

Add sugar and milk

Another drink.

--------------------------------

The result is "one more drink" ...

We can also use hooks like this to determine if the code inside is executing

1> we modify the template class (beverage)

Java code

2. Package com.kaishengit.beverage;
6. Public abstract class Beverage {
8. /** 
10. * Brew coffee or tea ... Process
12. */
14. public final void Create () {
16. Boilwater (); //Boil the water
18. Brew (); //Brew with boiling water ...
20. Pourincup (); //Put ... Pour into the cup
24. //Hooks decide whether to add ingredients
26. if (Hook ()) {
28. Addcoundiments (); //Plus ...
30. }
32. //hook ();
34. }
38. /** 
40. * Add Ingredients by default
42. * @return
44. */
46. Public Boolean hook () {
48. return true;
50. }
54. //public void Hook () {}
58. public abstract void addcoundiments ();
62. public abstract Void Brew ();
66. public void Boilwater () {
68. System.out.println ("boiled water");
70. }
74. public void Pourincup () {
76. System.out.println ("pour into cup");
78. }
80. }

2> We modify the coffee class so that it does not add ingredients

Java code

2. Package com.kaishengit.beverage;
6. Public class Coffee extends beverage{
10. @Override
12. public void Addcoundiments () {
14. System.out.println ("Add sugar and milk"); }  
18. @Override
20. public Void Brew () {
22. System.out.println ("Brew Coffee with water");
24. }
28. /** 
30. * Some guests do not like to add ingredients
32. */
34. @Override
36. Public Boolean hook () {
38. return false;
40. }
44. / * @Override
46. public void Hook () {
48. System.out.println ("One more Cup");
50. }
52. */
54. }

3> or use the test class above

Operation Result:

------------------------------------------------------

Boiled boiled water

Coffee with water

Pour into the cup

------------------------------------------------------

No ingredients added in running results

About template mode

The 1> template pattern defines the steps of the algorithm, delaying the implementation of these steps to subclasses

2> template mode provides us with a code reuse technique.

3> Template Abstract classes can define specific methods, abstract methods, and Hook methods

4> to prevent subclasses from changing the algorithm in the template, the template method can be declared as final

A 5> hook is a method that does not work in an abstract class, or only does the default, and subclasses can choose to implement it

Template Pattern Pattern method