Template Method pattern in LLD - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define the abstract method in the base class.

LLD

class AbstractClass:
    def template_method(self):
        self.base_operation1()
        self.[1]()
        self.base_operation2()

    def base_operation1(self):
        print("Base operation 1")

    def base_operation2(self):
        print("Base operation 2")

    def [1](self):
        pass

Drag options to blanks, or click blank then click option'

Aprimitive_operation

Btemplate_method

Cbase_operation1

Dhook

Attempts:

3 left

💡 Hint

Common Mistakes

Using the template_method name for the abstract method.

Overriding base_operation1 instead of the abstract method.

The Template Method pattern requires defining an abstract method (primitive_operation) that subclasses override.

2fill in blank

medium

Complete the code to override the primitive operation in the subclass.

LLD

class ConcreteClass(AbstractClass):
    def [1](self):
        print("Concrete implementation of primitive operation")

Drag options to blanks, or click blank then click option'

Atemplate_method

Bbase_operation2

Cprimitive_operation

Dhook

Attempts:

3 left

💡 Hint

Common Mistakes

Overriding template_method instead of primitive_operation.

Not overriding any method.

Subclasses override the primitive_operation method to provide specific behavior.

3fill in blank

hard

Fix the error in the template method to call the correct primitive operation.

LLD

def template_method(self):
    self.base_operation1()
    self.[1]()
    self.base_operation2()

Drag options to blanks, or click blank then click option'

Aprimitive_operation

Btemplate_method

Cbase_operation1

Dhook

Attempts:

3 left

💡 Hint

Common Mistakes

Calling template_method recursively causing infinite loop.

Calling base_operation1 twice.

The template method must call the primitive_operation to allow subclass customization.

4fill in blank

hard

Fill both blanks to add a hook method and call it in the template method.

LLD

class AbstractClass:
    def template_method(self):
        self.base_operation1()
        self.primitive_operation()
        self.[1]()
        self.base_operation2()

    def [2](self):
        pass

Drag options to blanks, or click blank then click option'

Ahook

Bprimitive_operation

Dtemplate_method

Attempts:

3 left

💡 Hint

Common Mistakes

Using the same name for both blanks incorrectly.

Not defining the hook method at all.

The hook method is optional and called in the template method; it is defined as an empty method in the base class.

5fill in blank

hard

Fill all three blanks to implement a concrete hook method and call the template method.

LLD

class ConcreteClass(AbstractClass):
    def primitive_operation(self):
        print("Concrete primitive operation")

    def [1](self):
        print("Concrete hook operation")

obj = ConcreteClass()
obj.[2]()

# Output should show base_operation1, primitive_operation, hook, base_operation2

# Call the template method named [3]

Drag options to blanks, or click blank then click option'

Ahook

Btemplate_method

Dprimitive_operation

Attempts:

3 left

💡 Hint

Common Mistakes

Calling primitive_operation directly instead of template_method.

Not overriding the hook method.

The concrete hook method overrides the base hook; the template_method is called on the object to run the algorithm.

Practice

1. What is the main purpose of the Template Method pattern in system design?

easy

A. To replace all methods with completely new implementations

B. To define a fixed sequence of steps with some customizable parts

C. To allow direct modification of the entire process by subclasses

D. To create multiple unrelated classes with no shared behavior

Solution

1. Step 1: Understand the Template Method pattern goal

   The pattern fixes the overall process flow but allows subclasses to customize certain steps.

2. Step 2: Analyze each option

   To define a fixed sequence of steps with some customizable parts correctly describes this fixed sequence with customizable parts. Options A, B, and C do not match the pattern's intent.

3. Final Answer:

   To define a fixed sequence of steps with some customizable parts -> Option B

4. Quick Check:

   Template Method = fixed process + flexible steps [OK]

Hint: Remember: fixed order, flexible details [OK]

Common Mistakes:

• Thinking subclasses rewrite the whole process
• Confusing Template Method with Strategy pattern
• Believing the pattern removes all common code
• Assuming no steps are customizable

2. Which of the following is the correct way to declare a template method in a class?

easy

A. Override all methods in subclasses without calling base methods

B. Define multiple unrelated methods without calling each other

C. Define a method that calls other methods in a fixed order

D. Use a method that randomly calls other methods

Solution

1. Step 1: Identify the structure of a template method

   A template method is a method that defines the sequence of steps by calling other methods in order.

2. Step 2: Evaluate each option

   Define a method that calls other methods in a fixed order matches this definition. Options B, C, and D do not follow the fixed sequence concept.

3. Final Answer:

   Define a method that calls other methods in a fixed order -> Option C

4. Quick Check:

   Template method = fixed calls order [OK]

Hint: Template method calls steps in order [OK]

Common Mistakes:

• Not calling methods in a fixed sequence
• Overriding template method instead of steps
• Ignoring the fixed process structure
• Using random or unordered calls

3. Consider this simplified template method code in Python:

class Game:
    def play(self):
        self.start()
        self.play_turn()
        self.end()

    def start(self):
        print('Game started')

    def play_turn(self):
        print('Playing turn')

    def end(self):
        print('Game ended')

class Chess(Game):
    def play_turn(self):
        print('Chess turn played')

chess = Chess()
chess.play()

What will be the output when chess.play() is called?

medium

A. Game ended
Chess turn played
Game started

B. Chess turn played
Game started
Game ended

C. Game started
Playing turn
Game ended

D. Game started
Chess turn played
Game ended

Solution

1. Step 1: Trace the play() method calls

   The play() method calls start(), play_turn(), and end() in order.

2. Step 2: Identify overridden methods

   Chess overrides play_turn(), so Chess's version prints 'Chess turn played'. start() and end() use base class prints.

3. Final Answer:

   Game started Chess turn played Game ended -> Option D

4. Quick Check:

   Template calls base start/end + overridden play_turn [OK]

Hint: Overridden steps print their own messages [OK]

Common Mistakes:

• Ignoring method overriding
• Assuming base play_turn() runs
• Mixing order of prints
• Thinking play() is overridden

4. In the following code, what is the main problem that breaks the Template Method pattern?

class Report:
    def generate(self):
        self.load_data()
        self.process_data()
        self.save_report()

    def load_data(self):
        print('Loading data')

    def process_data(self):
        print('Processing data')

    def save_report(self):
        print('Saving report')

class CustomReport(Report):
    def generate(self):
        print('Custom generate start')
        self.load_data()
        self.process_data()
        self.save_report()
        print('Custom generate end')

medium

A. The subclass overrides the template method instead of steps

B. The base class does not define any methods

C. The subclass does not call any base methods

D. The base class methods are private

Solution

1. Step 1: Identify the template method and overrides

   The base class defines generate() as the template method. The subclass overrides generate() itself.

2. Step 2: Understand Template Method pattern rules

   In this pattern, subclasses should override steps, not the template method, to keep the fixed process intact.

3. Final Answer:

   The subclass overrides the template method instead of steps -> Option A

4. Quick Check:

   Template method must not be overridden [OK]

Hint: Override steps, not the template method [OK]

Common Mistakes:

• Overriding the whole template method
• Ignoring base class method definitions
• Assuming private methods cause issues
• Thinking subclass must call base generate() explicitly

5. You are designing a document processing system where each document type requires a specific sequence of steps: open, parse, validate, save, and close. You want to ensure the sequence is fixed but allow each document type to customize parsing and validation. How should you apply the Template Method pattern here?

hard

A. Create a base class with a template method calling open, parse, validate, save, close; subclasses override parse and validate

B. Let each subclass implement its own full process without a base class

C. Use separate unrelated classes for each step without a fixed sequence

D. Make all steps abstract and force subclasses to implement the entire process

Solution

1. Step 1: Identify fixed and customizable parts

   The sequence (open, parse, validate, save, close) is fixed; parse and validate vary by document type.

2. Step 2: Apply Template Method pattern correctly

   Create a base class with a template method that calls all steps in order. Subclasses override parse and validate to customize behavior.

3. Final Answer:

   Create a base class with a template method calling open, parse, validate, save, close; subclasses override parse and validate -> Option A

4. Quick Check:

   Fixed sequence + customizable steps = Template Method [OK]

Hint: Fix sequence in base; override variable steps in subclasses [OK]

Common Mistakes:

• Not fixing the sequence in one place
• Forcing subclasses to rewrite entire process
• Ignoring the need for a template method
• Separating steps without order control