Template Design Pattern

1
Template Design Pattern

• Design Pattern Template Method
• Category Behavioural
• Intent Define the skeleton of an algorithm in a
  method, deferring some steps to subclasses, thus
  allowing the subclasses to redefine certain steps
  of the algorithm.
• Applicability
• to implement the invariant parts of an algorithm
  once and leave it up to the subclasses to
  implement the behaviour that can vary.
• to factorize and localize the common behaviour
  among subclasses to avoid code duplication.

GenericClass templateMethod() hookMethod1() hookMe
thod2()
hookMethod1() hookMethod2()
ConcreteClass hookMethod1() hookMethod2()
2
Strategy Design Pattern

• Design Pattern Strategy
• Category Behavioural
• Intent Define a family of algorithms,
  encapsulate each one, and make them
  interchangeable.
• Applicability
• many related classes differ only in their
  behaviour.
• you need different variants of an algorithm.
• an algorithm uses data that clients shouldn't
  know about.
• a class defines many behaviours, and these appear
  as multiple conditional statements in its methods.

3
Animating Algorithms
public abstract class AlgorithmAnimator
extends DBAnimationApplet // the hook method
abstract protected void algorithm() // the
template method public void run()
algorithm() final protected void pause()
if (Thread.currentThread()
animationThread) try
Thread.sleep(delay) catch
(InterruptedException e) repaint()

4
Animating Sorting Algorithms I
import java.awt. public class Sort extends
AlgorithmAnimator ltMethod scramble()gt -
initializes and scrambles the array ltMethod
paintFrame()gt ltMethod bubbleSort()gt ltMethod
quickSort()gt ltMethod initAnimator()gt -
initializes the animation ltMethod algorithm()gt
- chooses the algorithm ltMethod swap()gt //
the array to be sorted protected int arr
// the name of the algorithm to be animated
protected String algName
5
Separate the Algorithms

• Make different algorithms interchangeable
  components.
• Adding and changing algorithms will have little
  impact on the animation mechanism.
• Use strategy design pattern

6
Separating and encapsulating sorting algorithms
Algorithm Animator algorithm()
SortAlgorithm sort()
Sort2 algorithm()
BubbleSortAlgorithm sort()
QuickSortAlgorithm sort()
7
The Abstract Algorithm
abstract public class SortAlgorithm abstract
void sort(int a) private AlgorithmAnimator
animator protected SortAlgorithm(AlgorithmAnim
ator animator)
this.animator animator protected void
pause() if (animator ! null)
animator.pause() protected static void
swap(int a, int
i, int j) int T T ai ai aj
aj T
8
A Concrete Algorithm
public class BubbleSortAlgorithm extends
SortAlgorithm public void sort(int a)
for (int i a.length --i gt 0 ) for
(int j 0 j lt i j) if (aj gt
aj1) swap(a, j, j1)
pause() public
BubbleSortAlgorithm(AlgorithmAnimator
animator)
super(animator)
9
Design PatternFactory
Design Pattern Factory Category
Creational Intent Define an interface for
creating objects but let subclasses decide which
class to instantiate and how. Applicability The
factory design pattern should be used when a
system should be independent of how its products
are created
10
Factory design Pattern
AbstractFactory makeProduct()
Product
ConcreteFactory makeProduct()
ConcreteProduct
11
The Abstract Algorithm Factory
public interface AlgorithmFactory public
SortAlgorithm makeSortAlgorithm(String
algName)
12
A Concrete Algorithm Factory
public class StaticAlgoFactory implements
AlgorithmFactory public StaticAlgoFactory(Algo
rithmAnimator animator)
this.animator animator public
SortAlgorithm makeSortAlgorithm( String
algName) if ("BubbleSort".equals(algName))
return new BubbleSortAlgorithm(animator)
else if ("QuickSort".equals(algName))
return new QuickSortAlgorithm(animator)
else return new BubbleSortAlgorithm(animat
or) protected AlgorithmAnimator
animator
13
Sorting Algorithm Animation II
public class Sort2 extends AlgorithmAnimator
protected SortAlgorithm theAlgorithm
protected SortAlgorithmFactory algorithmFactory
protected void initAnimator() algName
"BubbleSort" String at getParameter("alg")
if (at ! null) algName at
algorithmFactory new
StaticAlgoFactory(this) theAlgorithm
algorithmFactory.makeSortAlgorithm(algName)
setDelay(20) scramble()
14
Separate the Display Component
Sort2
HSortDisplay
VSortDisplay
SortDisplay
Sort3
BSortDisplay
SortDisplayFactory
BarSortDisplay
StaticSortDisplayFactory
15
SortDisplay Design Option 1

• Very small interface
• public interface SortDisplay
• public void display(int a, Graphics g,
• Dimension d)
• Minor changes to the main class. The
  paintFrame() method becomes
• public void paintFrame(Graphics g)
• theDisplay.display(arr, g, getSize())

16
SortDisplay Design Option 1 (cont'd)

• Problems
• Strong coupling between the main class and the
  implementations of SortDisplay.
• Limited flexibility.
• What about drawing lines vertically?
• What about drawing lines of 3 pixels wide?

17
SortDisplay Design Option 2

• Include scramble() in the SortDisplay
• public interface SortDisplay
• public void scramble(int a, Dimension d)
• public void display(int a, Graphics g,
• Dimension d)
• The scramble() method in the main class becomes
• void scramble()
• theDisplay.scramble(arr, getSize())

18
SortDisplay Design Option 2 (cont'd)

• The coupling between the main class and the
  implementations of SortDisplay is reduced.
• The methods of SortDisplay are not very cohesive.
  
• Scrambling is quite independent from displaying.
• The only interdependence between the two methods
  are --- the array size.

19
SortDisplay Design Option 3

• The SortDisplay interface
• public interface SortDisplay
• public int getArraySize(Dimension d)
• public void display(int a, Graphics g,
• Dimension d)
• The scramble() method in the main class becomes
• void scramble()
• int n theDisplay.getArraySize(getSize())
• arr new intn
• // scramble the numbers in arr0..(n-1)

20
Animating Sorting Algorithms III
public class Sort3 extends Sort2 protected
SortDisplay theDisplay protected
SortDisplayFactory displayFactory protected
void initAnimator() String att
getParameter("dis") displayFactory
new StaticSortDisplayFactory() theDisplay
displayFactory.makeSortDisplay(att)
super.initAnimator()
21
Animating Sorting Algorithms III (cont'd)
(class Sort3 continued) protected void
scramble() int n theDisplay.getArraySize(g
etSize()) arr new intn for (int i
arr.length --i gt 0) arri i
for (int i arr.length --i gt 0) int j
(int)(i Math.random())
SortAlgorithm.swap(arr, i, j)
protected void paintFrame(Graphics g)
theDisplay.display(arr, g, getSize())
22
Display Strategies