We're now going to take a look at another design pattern and this one is called template method and
it's all about providing once again high level blueprints of an algorithm to be completed by its inheritors.
Now this might seem familiar to you because we've seen something like this already in the Strategy pattern
so essentially we know that algorithms generally can be decomposed into the common parts or the high
level parts as well as the specifics and the Strategy pattern over the kind of handles that for us or
why do we need yet another design pattern where the Strategy pattern does this through composition.
So essentially you have the high level algorithm which uses some interface and then the concrete implementations
actually implement this interface and then you stick them in.
And it works the template method is very similar except it does this through inheritance instead.
So the overall algorithm would typically be an abstract base class and then of course what you have
is you have inheritors of this anger which overrides certain key abstract members but the base class
actually keeps the template for the actual algorithms so the parent template method the method which
is not abstract is then invoked to actually orchestrate the algorithm at the high level.
So the Template Method design pattern quite simply allows us to define the skeleton of the algorithm
in the base class with concrete implementations defined in these subclasses.