Why creational patterns manage object creation in LLD - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create an object using a creational pattern.

LLD

object = [1]()

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

AFactory

BBuilder

CSingleton

DObserver

Attempts:

3 left

💡 Hint

Common Mistakes

Choosing Observer which is for event handling, not creation.

The Factory pattern is used to create objects without specifying the exact class.

2fill in blank

medium

Complete the code to ensure only one instance of a class is created.

LLD

class Singleton:
    _instance = None

    def __new__(cls):
        if [1] is None:
            cls._instance = super().__new__(cls)
        return cls._instance

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

Acls.instance

Bcls

Ccls._instance

Dcls._singleton

Attempts:

3 left

💡 Hint

Common Mistakes

Using cls.instance which is not defined.

The Singleton pattern checks if the instance exists using cls._instance.

3fill in blank

hard

Fix the error in the Builder pattern method to return the final product.

LLD

class Builder:
    def __init__(self):
        self.product = []

    def add_part(self, part):
        self.product.append(part)

    def get_result(self):
        return [1]

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

Aself

Bproduct

Cpart

Dself.product

Attempts:

3 left

💡 Hint

Common Mistakes

Returning 'product' without self causes a NameError.

The method should return the product stored in self.product.

4fill in blank

hard

Fill both blanks to create a Factory method that returns a new object.

LLD

def factory_method(type):
    if type == 'A':
        return [1]()
    else:
        return [2]()

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

AProductA

BProductB

CProductC

DProductD

Attempts:

3 left

💡 Hint

Common Mistakes

Using the same product class for both types.

The factory method returns ProductA or ProductB objects based on the type.

5fill in blank

hard

Fill all three blanks to complete the Singleton pattern implementation.

LLD

class Singleton:
    _instance = None

    def __new__(cls):
        if [1] is None:
            [2] = super().__new__(cls)
        return [3]

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

Acls._instance

Dcls

Attempts:

3 left

💡 Hint

Common Mistakes

Using different variable names causing errors.

All blanks refer to the class variable cls._instance to ensure only one instance is created and returned.

Practice

1. Why do creational design patterns manage object creation in software design?

easy

A. To separate the process of creating objects from their usage, improving flexibility

B. To make the code run faster by avoiding object creation

C. To reduce the number of objects created to save memory

D. To enforce strict typing of objects in the system

Solution

1. Step 1: Understand the purpose of creational patterns

   Creational patterns focus on how objects are created, aiming to separate creation from usage.

2. Step 2: Identify the benefit of this separation

   This separation allows the system to be more flexible and easier to maintain or extend.

3. Final Answer:

   To separate the process of creating objects from their usage, improving flexibility -> Option A

4. Quick Check:

   Object creation separation = Flexibility [OK]

Hint: Creational patterns separate creation from use for flexibility [OK]

Common Mistakes:

• Thinking creational patterns only improve speed
• Confusing object creation with memory optimization
• Assuming creational patterns enforce type rules

2. Which of the following is the correct syntax to implement a simple Factory Method pattern in Python?

easy

A. def Factory():
return Product()

B. class Factory:
def create(self):
return Product()

C. class Factory:
def create():
return Product()

D. class Factory:
def create(self):
return Product

Solution

1. Step 1: Check method definition with self parameter

   In Python, instance methods must have 'self' as the first parameter.

2. Step 2: Verify the method returns an instance, not a class

   The method should return an instance of Product, so 'Product()' is correct, not 'Product'.

3. Final Answer:

   class Factory: def create(self): return Product() -> Option B

4. Quick Check:

   Method with self and returns instance = class Factory: def create(self): return Product() [OK]

Hint: Instance methods need 'self' and return object instances [OK]

Common Mistakes:

• Omitting 'self' in method definition
• Returning class instead of instance
• Defining method without parameters

3. Given the following code snippet implementing a Singleton pattern, what will be the output?

class Singleton:
    _instance = None
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

obj1 = Singleton()
obj2 = Singleton()
print(obj1 is obj2)

medium

A. False

B. Error

C. True

D. None

Solution

1. Step 1: Understand Singleton __new__ method behavior

   The __new__ method ensures only one instance is created by storing it in _instance.

2. Step 2: Check if obj1 and obj2 refer to the same instance

   Both obj1 and obj2 call Singleton(), which returns the same _instance object.

3. Final Answer:

   True -> Option C

4. Quick Check:

   Singleton returns same instance = True [OK]

Hint: Singleton returns same object, so 'is' comparison is True [OK]

Common Mistakes:

• Assuming new instance created each call
• Confusing 'is' with '=='
• Expecting None or error output

4. Identify the error in the following Builder pattern implementation snippet:

class Builder:
    def __init__(self):
        self.product = Product()
    def build_part(self):
        self.product.add('part')
    def get_product(self):
        return self.product

builder = Builder()
builder.build_part()
product = builder.get_product()
print(product.parts)

medium

A. print statement syntax is incorrect

B. build_part method does not add parts correctly

C. get_product method returns None instead of product

D. Product class is not defined, causing a NameError

Solution

1. Step 1: Check for class definitions used

   The code uses 'Product' but does not define it anywhere, leading to NameError.

2. Step 2: Verify other method correctness

   Methods build_part and get_product are syntactically correct assuming Product exists.

3. Final Answer:

   Product class is not defined, causing a NameError -> Option D

4. Quick Check:

   Undefined Product class = NameError [OK]

Hint: Undefined classes cause NameError, check all class definitions [OK]

Common Mistakes:

• Assuming Product class exists by default
• Blaming method logic instead of missing class
• Ignoring error messages

5. In a large system, why is it beneficial to use creational patterns like Abstract Factory instead of directly instantiating objects with new or constructors?

hard

A. It allows the system to create families of related objects without specifying their concrete classes

B. It guarantees the system uses less memory by reusing objects automatically

C. It forces all objects to be created at compile time for faster execution

D. It removes the need for interfaces or abstract classes in the design

Solution

1. Step 1: Understand Abstract Factory pattern purpose

   This pattern provides an interface to create families of related objects without specifying their concrete classes.

2. Step 2: Analyze benefits in large systems

   It improves scalability and flexibility by decoupling object creation from usage and allowing easy swapping of object families.

3. Final Answer:

   It allows the system to create families of related objects without specifying their concrete classes -> Option A

4. Quick Check:

   Abstract Factory = Create related objects flexibly [OK]

Hint: Abstract Factory creates related objects without concrete classes [OK]

Common Mistakes:

• Thinking it reduces memory automatically
• Believing it forces compile-time creation
• Assuming it removes need for interfaces