Can anyone let me know some example situations where Template Method - pattern should be used?
Give me some real-world use from your own experience.
(I have so far found it useful only for mapping data in the DA layer. Sorry!!!)
I tried to give you some real-world examples, and some common situations where Template Method pattern should be used.
When you want your program be "Open For Extension” and also “Closed for Modification”. This means that the behavior of the module can be extended, such that we can make the module behave in new and different ways as the requirements of the application change, or to meet the needs of new applications. However, The source code of such a module is inviolate. No one is allowed to make source code changes to it. In following example, you can add new manner of salary calculation (such as Remotely class) without changing the previous codes.
public abstract class Salary {
public final void calculate() {
System.out.println("First shared tasks is done.");
getBaseSalary();
System.out.println("Second shared tasks is done.");
}
public abstract void getBaseSalary();
}
public class Hourly extends Salary {
@Override
public void getBaseSalary() {
System.out.println("Special Task is done.");
}
}
public class Test {
public static void main(String[] args) {
Salary salary = ....
salary.calculate();
}
}
When you face many same line of codes that are duplicated through deferring just some steps of your algorithm. When you are implementing content of a method or function you can find some section of your code that vary from one type to another type. The feature of this sections are that one can redefine or modify these sections of an method or function without changing the algorithm's (method or function) main structure. For example if you want to solve this problem without this pattern you will face this sample:
function0: function1: ... functionN:
1 1 1
2 2 2
... ... ...
5 6 n
3 3 3
4 4 4
... ... ...
As you can see, section cods 5, 6, n are different vary from one function to another function, however you have shared sections such as 1,2,3,4 that are duplicated. Lets consider a solution with one of famous java libraries.
public abstract class InputStream implements Closeable {
public abstract int read() throws IOException;
public int read(byte b[], int off, int len) throws IOException {
....
int c = read();
....
}
....
}
public class ByteArrayInputStream extends InputStream {
...
public synchronized int read() {
return (pos < count) ? (buf[pos++] & 0xff) : -1;
}
...
}
When you as a designer of a framework, want that your clients just to use any executable code that is passed as an argument to your framework, which is expected to call back (execute) that argument at a given time. This execution may be immediate as in a synchronous callback, or it might happen at a later time as in an asynchronous callback. Lets consider one of famous ones.
public abstract class HttpServlet extends GenericServlet
implements java.io.Serializable {
protected void doGet(HttpServletRequest req, HttpServletResponse resp) {
...
}
protected void service(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
....
doGet(req, resp);
...
}
...
}
}
public class MyServlet extends HttpServlet {
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
//do something
...
}
...
}