Template method design pattern for beginners.

-

Problem statement –

Please go through the strategy design pattern before you continue reading this article. From the strategy design pattern, we understand that; how to build an application, where you want the user to select the approach of solving/executing problem/algorithm at run time. For a moment, imagine template methods design pattern doing the same thing but in a controlled way.

Let us understand it through an example, there are 4 outstanding programmers. Like you! Writing code to solve a given problem. According to the strategy design pattern, it just wants a result. Not interested in how different programmers have written their code. And what approach/strategy they have followed to solve the problem. As long as they can implement various strategies in different strategy, concrete implementation.

Now those 4 programmers have joined the same software company and solves a given problem. This time as they have joined same company, all of them have to follow company-specific guidelines. i.e., how to write company standard code, what predefined third-party library they can use, or what they cannot use as per company’s build environment, and some other restrictions. Yes, they can use different algorithms to solve that problem, but at the same time, they have to follow all other restrictions imposed by the company. 

 So, in summary, template method design pattern restricts concrete implementer to follow specific rules, and also gives some freedom to implement their own algorithms.

Strategy design pattern is an uncontrolled way of implementing things. In contrast, template method design pattern is a controlled way to achieve your software solution, so it is up to the designer in what way he would like to implement, both have their own merits and demerits. 

About template method design pattern –

In this design pattern, we will put all generic logic in base class and let the derived classes have their own specific implementations.

Structure –

template method DP
UML structure of template method design pattern.

Example –

In this example, you have a different source of playing the music. But what options your music system will show on the screen is restricted and driven by your base class.

template method Dp Ex
example of template method design pattern (Click on picture to see zoom view)



 

#include <iostream>
using namespace std;

class MusicSysem
{
    public:
        // go to next song
        void next()
        {
            cout<< "Play next song" << endl;
        }
        // go to previous song 
        void previous()
        {
            cout<< "Play previous song" << endl;
        }
        void pause()
        {
            cout<< "Pause song" << endl;
        }
        void off()
        {
            cout<< "Switch off the system" << endl;
        }
        void on()
        {
            cout<< "Switch on the system" << endl;
        }
        virtual void showDisplayMenue() = 0;
};
//*************************************************************************************
class Radio: public MusicSysem
{
    public:
        void showDisplayMenue()
        {
            cout<< "Hi welcome to radio system" << endl;
        }
};
//*************************************************************************************
class CDPlayer: public MusicSysem
{
    public:
        void showDisplayMenue()
        {
            cout<< "Hi welcome to CD Player system" << endl;
        }
};
//*************************************************************************************
class USB: public MusicSysem
{
    public:
        void showDisplayMenue()
        {
            cout<< "Hi welcome to USB Player system" << endl;
        }
};
/*
#######################################################################################
#########  __  __       _        ######################################################
######### |  \/  | __ _(_)_ __   ######################################################
######### | |\/| |/ _` | | '_ \  ######################################################
######### | |  | | (_| | | | | | ######################################################
######### |_|  |_|\__,_|_|_| |_| ######################################################
#######################################################################################
*/
int main(int argc, char** argv)
{
    MusicSysem *musicSysemPtr;
    int choice;
    cout<< "Welcome to my music system "<< endl;
    cout<< "Press 1 for Radio " << endl;
    cout<< "Press 2 for CDPlayer " << endl;
    cout<< "Press 3 for USB " << endl;
    cin >> choice;
    switch(choice)
    {
        case 1:
            musicSysemPtr = new Radio;
            musicSysemPtr->on();
            musicSysemPtr->showDisplayMenue();
            musicSysemPtr->next();
            musicSysemPtr->previous();
            musicSysemPtr->pause();
            musicSysemPtr->off();
            break;
        case 2:
            musicSysemPtr = new CDPlayer;
            musicSysemPtr->on();
            musicSysemPtr->showDisplayMenue();
            musicSysemPtr->next();
            musicSysemPtr->previous();
            musicSysemPtr->pause();
            musicSysemPtr->off();
            break;
        case 3:
            musicSysemPtr = new USB;
            musicSysemPtr->on();
            musicSysemPtr->showDisplayMenue();
            musicSysemPtr->next();
            musicSysemPtr->previous();
            musicSysemPtr->pause();
            musicSysemPtr->off();
            break;
        default:
            cout<< "You have entered wrong choice";
    }
    
    return 0;
}

///////////////////////////////////////////////////////////////////-------------OutPut
/*
$ ./a.exe
Welcome to my music system
Press 1 for Radio
Press 2 for CDPlayer
Press 3 for USB
1
Switch on the system
Hi welcome to radio system
Play next song
Play previous song
Pause song
Switch off the system
-------------------------------------
$ ./a.exe
Welcome to my music system
Press 1 for Radio
Press 2 for CDPlayer
Press 3 for USB
2
Switch on the system
Hi welcome to CD Player system
Play next song
Play previous song
Pause song
Switch off the system
-------------------------------------
$ ./a.exe
Welcome to my music system
Press 1 for Radio
Press 2 for CDPlayer
Press 3 for USB
3
Switch on the system
Hi welcome to USB Player system
Play next song
Play previous song
Pause song
Switch off the system

*/



Thanks for reading it. To learn more about design patterns and basic design principles, please see my web page.

Comments

Post a Comment

Popular posts from this blog

Non-virtual interface idiom (NVI)

-
In almost every cases, it’s recommended to follow OOAD principles, but sometimes we should try to look some other alternatives, provided by programming languages, which could be a better options for certain situations. In C++, we can implement virtual function in private and we can redefine its behavior in derived class's private  and it will work in same way(did you try that?). When we define virtual function as private and expose a non-virtual public function to outer world, we call it “ non-virtual interface idiom ”. Non-virtual public function will internally call virtual function, in other words you are not exposing your virtual function to client. You will achieve high encapsulation, plus we can add pre and post execution/condition in the body of non-virtual public function. Call some set of functions, as prerequisite of calling virtual function, and after call returns from virtual function, again call some set of function as part of post cleanups/conditions,
Read more

Architectural patterns => Mud to structure => layers.

-
Image
Background - We apply mud to structure when a large system requires decomposition. If you notice, your application/requirement has verity of logical units which can be decomposed into a group of sub-tasks, first,  group them into different levels of abstraction. One abstract unit perform a totally different task(s) from other units, but any unit alone is not enough to give meaningful service to customer. Actually, different issues/solutions are splinted into different abstract units. Second,  after you divide them into different units, if you see a mix of low and high-level dependencies, where high-level operations depend on low-level operations, then assume those logical units as layers, third draw a dependency diagram between layers.  If control flows from high to low layer (or dependency diagram forms a stack, one layer on top of other), you can think of implementing it through layer pattern. Layer architecture - We can have many components in one layer. Layer
Read more

Architectural style -> Adoptable system -> Reflection.

-
Image
Background - We have discussed very less about reflection, especially if you are C, C++, mainframe, LSI developer and working on server side implementation or in low level hardware-interaction development team.  But it is very popular among high level languages like JAVA, Scala, C#, Python etc, many languages have implemented reflection in it.  It gives you flexibility to do things dynamically (at run-time). After working closely with different clients, you will get a clear understanding that no one is as confusing as a software client, not even your girlfriend! So we should have a flexible architecture in place who can absorb shocks of client’s last moment changes. Not only that, sometimes we have N number of different behaviors and structure in place, and we want our application to behave differently depending upon run-time situations. Let’s build understanding step by step through an example. Think you have got an assignment where you have to build an application
Read more