Shulou(Shulou.com)06/02 Report--

This article mainly introduces "how to use java template pattern". In daily operation, I believe many people have doubts about how to use java template pattern. The editor consulted all kinds of materials and sorted out simple and easy-to-use operation methods. I hope it will be helpful for you to answer the doubts about "how to use java template pattern". Next, please follow the editor to study!

I. introduction

The template pattern, as its name implies, defines a template that implements part of the logic in the form of concrete methods or concrete constructors, and declares some abstract methods in abstract classes to force subclasses to implement the rest of the logic.

Different subclasses can implement these abstract methods in different ways, and thus have different implementations of the remaining logic, which is the purpose of the template method pattern.

The template pattern involves three roles:

Abstract class (AbstractClass): implements the template method and defines the skeleton of the algorithm

Concrete class (ConcreteClass): implements abstract methods in abstract classes, and has completed a complete algorithm

Customer role: the customer class makes a request to use a specific class

2. Examples

For example, take the operation needed to get up in the morning and go to work as an example, the general process can be divided into the following steps: dressing, brushing your teeth, washing your face, eating breakfast, etc. There may be some differences in the operation between boys and girls.

Let's create an abstract class and define the general operation flow, as follows:

/ * * abstract class * / public abstract class AbstractPerson {/ * define the operation flow * / public void prepareGoWorking () {dressing (); / / dress brushTeeth (); / / brush your teeth washFace (); / / wash your face eatBreakFast (); / / eat breakfast} / * * dress * / protected abstract void dressing () / * * Brush your teeth * / protected void brushTeeth () {System.out.println ("brushing");} / * * wash your face * / protected void washFace () {System.out.println ("wash your face");} / * * have breakfast * / protected abstract void eatBreakFast ();}

Because the behaviors of boys and girls are different, we create two specific classes, as follows:

/ * male * concrete implementation class * / public class ManPerson extends AbstractPerson {@ Override protected void dressing () {System.out.println ("wear a suit");} @ Override protected void eatBreakFast () {System.out.println ("eat breakfast directly in the office") }} / * Girl * concrete implementation class * / public class WomanPerson extends AbstractPerson {@ Override protected void dressing () {System.out.println ("wear casual clothes");} @ Override protected void eatBreakFast () {System.out.println ("get something to eat at home or buy a snack outside");}}

Create a client and implement the following:

Public class TemplateClient {public static void main (String [] args) {/ / Boys get up step ManPerson manPerson = new ManPerson (); System.out.println ("- Boys get up step--"); manPerson.prepareGoWorking (); System.out.println ("- Girl get up step -") / / step for girls to get up WomanPerson womanPerson = new WomanPerson (); womanPerson.prepareGoWorking ();}}

Output result:

Steps for boys to get up-wear suits, brush teeth and wash faces, eat breakfast at work directly-girls get up-wear casual clothes, brush teeth, wash faces, get something to eat at home, or buy some snacks outside

Of course, the template mode of play, not only these, but also in the template mode to use hooks (hook).

What is hook? There is a method of empty implementation, which we call hook. The subclass can decide whether to overwrite it or not depending on the situation.

Or take the above as an example, for example, you have to go to work after breakfast, which means of transportation to choose?

A new method hook () is added to the abstract class, which is as follows:

/ * abstract class * / public abstract class AbstractPerson {/ * define the operation flow * / public void prepareGoWorking () {dressing (); / / dressing brushTeeth (); / / brushing teeth washFace (); / / face washing eatBreakFast (); / / having breakfast hook () / / hook} / * * get dressed * / protected abstract void dressing (); / * * brush your teeth * / protected void brushTeeth () {System.out.println ("brush your teeth");} / * * wash your face * / protected void washFace () {System.out.println ("wash your face");} / * * have breakfast * / protected abstract void eatBreakFast () / * * hook * / protected void hook () {};}

The boy implements the class and overrides the hook () method as follows:

/ * male * concrete implementation class * / public class ManPerson extends AbstractPerson {@ Override protected void dressing () {System.out.println ("wear a suit");} @ Override protected void eatBreakFast () {System.out.println ("eat breakfast directly in the office") } @ Override protected void hook () {System.out.println ("go to work by subway");}}

Run the test class, the boy implements the class, and output the result:

-steps for boys to get up-wear suits, brush their teeth and wash their faces, eat breakfast at the company and take the subway to work.

Of course, there are other ways to play, such as girls may need makeup after washing their faces, we will deal with the abstract class again, the content is as follows:

/ * abstract class * / public abstract class AbstractPerson {/ * define the operation flow * / public void prepareGoWorking () {dressing (); / / dress brushTeeth (); / / brush teeth washFace () / / wash your face / / whether you need make-up or not, if (isMakeUp ()) {System.out.println ("make-up");} eatBreakFast (); / / eat breakfast hook (); / / hook} / * * whether you need make-up methods * / protected boolean isMakeUp () {return false } / * * get dressed * / protected abstract void dressing (); / * * brush your teeth * / protected void brushTeeth () {System.out.println ("brushing your teeth");} / * * wash your face * / protected void washFace () {System.out.println ("wash your face");} / * * have breakfast * / protected abstract void eatBreakFast () / * * hook * / protected void hook () {};}

The female student implements the class and overrides the isMakeUp () method as follows:

/ * Girl * concrete implementation class * / public class WomanPerson extends AbstractPerson {@ Override protected void dressing () {System.out.println ("wear casual clothes");} @ Override protected void eatBreakFast () {System.out.println ("get something to eat at home or buy a snack outside");} @ Override protected boolean isMakeUp () {return true }}

Run the test class, implement the class for girls, and output the results:

-steps for girls to get up-wear casual clothes, brush their teeth and wash their faces, make up and get something to eat at home, or buy some snacks outside

III. Application

Template design patterns are widely used, such as servlet in javaEE. Every time we create a servlet, we inherit HttpServlet. In fact, HttpServlet already provides us with a set of operation flow, we just need to rewrite the methods inside!

Some of the source codes of HttpServlet are as follows:

Public abstract class HttpServlet extends GenericServlet {protected void doGet (HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {/ /...} protected void doPost (HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {/ /...} protected void doHead (HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {/ /...} protected void doPut (HttpServletRequest req, HttpServletResponse resp) throws ServletException IOException {/ /...} protected void doDelete (HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {/ /...} protected void doOptions (HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {/...} protected void doTrace (HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {/ /...} protected void service (HttpServletRequest req, HttpServletResponse resp) throws ServletException IOException {String method = req.getMethod () If (method.equals (METHOD_GET)) {long lastModified = getLastModified (req); if (lastModified = =-1) {/ / servlet doesn't support if-modified-since, no reason / / to go through further expensive logic doGet (req, resp);} else {long ifModifiedSince = req.getDateHeader (HEADER_IFMODSINCE) If (ifModifiedSince < lastModified) {/ / If the servlet mod time is later, call doGet () / / Round down to the nearest second for a proper compare / / An ifModifiedSince of-1 will always be less maybeSetLastModified (resp, lastModified); doGet (req, resp) } else {resp.setStatus (HttpServletResponse.SC_NOT_MODIFIED);} else if (method.equals (METHOD_HEAD)) {long lastModified = getLastModified (req); maybeSetLastModified (resp, lastModified); doHead (req, resp) } else if (method.equals (METHOD_POST)) {doPost (req, resp);} else if (method.equals (METHOD_PUT)) {doPut (req, resp);} else if (method.equals (METHOD_DELETE)) {doDelete (req, resp) } else if (method.equals (METHOD_OPTIONS)) {doOptions (req,resp);} else if (method.equals (METHOD_TRACE)) {doTrace (req,resp) } else {/ Note that this means NO servlet supports whatever / / method was requested, anywhere on this server. / / String errMsg = lStrings.getString ("http.method_not_implemented"); Object [] errArgs = new Object [1]; errArgs [0] = method; errMsg = MessageFormat.format (errMsg, errArgs); resp.sendError (HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);}} / /. Omit.}

Customize a Servlet class for HelloWorld, as follows:

Import java.io.*; import javax.servlet.*; import javax.servlet.http.*; public class HelloWorld extends HttpServlet {public void init () throws ServletException {/ /...} public void doGet (HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {response.setContentType ("text/html"); PrintWriter out = response.getWriter (); out.println ("HelloWorld!") } public void destroy () {/ /.}} at this point, the study on "how to use the java template pattern" is over. I hope to be able to solve your doubts. The collocation of theory and practice can better help you learn, go and try it! If you want to continue to learn more related knowledge, please continue to follow the website, the editor will continue to work hard to bring you more practical articles!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.