Java design pattern-template method

Template refers to the sheet of plastic plate after the knockout, and then use a brush or a color pen to fill the hollowed out part, you can see the pure hand and without losing neat words, see the shape of the hollowing out of the template, immediately know what the final word will be changed, However, the actual appearance of the typeface depends on the type of brush used. Take the black pen as the brush, the result of course is the word of the pen; When you draw with a pencil, it will only be a gray-black pencil, and if you use colorful color pens, you can naturally create a dazzling multi-color word. However, no matter what kind of stationery , the words produced are still not able to remove the shape of the template has been fixed.

Below we illustrate the template method with examples

Relationship between program sample classes

1. template class, equivalent to the sheet plastic sheet we mentioned above

Java code

2. Package Com.pattern.templateMethod;
6. /**
8. * Abstract class, acting as template role
10. * @author Administrator
12. *
14. */
16. Public Abstract class Abstractdisplay {
18. //abstract method implemented by subclasses
20. public abstract Void open ();
22. public abstract void print ();
24. public abstract Void Close ();
26. //abstract class implementation method, final can guarantee that the subclass will not be modified
28. public final void display () {
30. Open (); //First Open ...
32. For (int i=0; i < 5; i++) { //Repeat Output 5 times
34. Print ();
36. }
38. Close (); //output complete, close
40. }
42. }

2. Character class, output single character

Java code

2. Package Com.pattern.templateMethod;
6. Public class Chardisplay extends Abstractdisplay {
8. private Char ch; //characters to be output
10. Public chardisplay (char ch) { //) pass the constructor over the character ch, stored in the field
12. this.ch = ch;
14. }
18. public Void Open () {
20. System.out.print ("<<"); //Output "<<" as Start string
22. }
24. public Void Close () {
26. System.out.println (">>"); //Output ">>" as end string
28. }
30. public void print () {
32. System.out.print (CH); //Output the characters stored in the field
34. }
38. }

3. String class, Output string

Java code

2. Package Com.pattern.templateMethod;
6. /**
8. *
10. * @author Administrator
12. */
14. Public class Stringdisplay extends Abstractdisplay {
16. private string string; //String to be output
18. private int width; //The "Length" of the string to be evaluated in bytes
22. Public Stringdisplay (string string) {
24. this.string =string;
26. width = string.getbytes (). length;
28. }
32. public Void Open () { //print head decoration string
34. PrintLine ();
36. }
38. public void print () { //print content
40. System.out.println ("|"  +string+"|");
42. }
44. public Void Close () { //print tail decoration string
46. PrintLine ();
48. }
52. public void PrintLine () {
54. System.out.print ("+"); //output "+" sign indicates border position
56. For (int i=0; i < width; ++i) {
58. System.out.print ("-"); //As Segment
60. }
62. System.out.println ("+"); //output "+" sign indicates border position
64. }
66. }

4. Test class

Java code

2. Package Com.pattern.templateMethod;
6. Public class Main {
8. public static void Main (string[] args) {
10. //Build 1 objects with ' a ' chardisplay
12. Abstractdisplay D1 = new Chardisplay (' A ');
14. //Build 1 objects with "Hello World" Stringdisplay
16. Abstractdisplay D2 = new Stringdisplay ("Hello World");
20. //d1,d2 are Abstractdisplay subclass objects that can call the inherited display () method
22. D1.display ();
24. D2.display ();
26. }
28. }

Output:

C code

1. <<AAAAA>>
2. +-----------+
3. | Hello world|
4. | Hello world|
5. | Hello world|
6. | Hello world|
7. | Hello world|
8. +-----------+

Design ideas:

As a template method is defined in the parent class (the parent class is an abstract class), and the method definition uses the abstract method, the implementation of the abstract method is a subclass, in order to implement the method in the subclass to determine the specific operation. If you implement different implementations in different subclasses, you can develop different processing content. However, regardless of the subclass in which the implementation is performed, the approximate process of processing is still based on the way the parent class is developed.

Java design pattern-template method