Abstract Factory pattern in LLD - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Purpose of Abstract Factory Pattern

What is the main purpose of using the Abstract Factory pattern in system design?

A To create families of related objects without specifying their concrete classes

B To allow a single object to change its behavior at runtime

C To provide a global point of access to a single instance

D To separate the construction of a complex object from its representation

💡 Hint

Think about how the pattern helps in creating groups of objects that belong together.

The Abstract Factory pattern provides an interface to create families of related or dependent objects without specifying their concrete classes, promoting consistency among products.

❓ Architecture

intermediate

Identifying Components in Abstract Factory

Which of the following correctly identifies the main components involved in the Abstract Factory pattern?

A Singleton, Observer, Subject, Concrete Observer

B Abstract Factory, Concrete Factory, Abstract Product, Concrete Product

C Builder, Director, Product, Concrete Builder

D Facade, Subsystem, Client, Adapter

💡 Hint

Focus on the roles that create and represent products in the pattern.

The Abstract Factory pattern involves an Abstract Factory interface, Concrete Factories implementing it, Abstract Products defining product interfaces, and Concrete Products implementing those interfaces.

❓ scaling

advanced

Scaling Abstract Factory for Multiple Product Families

When scaling a system using Abstract Factory to support multiple product families, which approach best maintains scalability and flexibility?

A Use inheritance to extend one Concrete Factory for all product families

B Use a single Concrete Factory that creates all products for all families

C Create a new Concrete Factory for each product family implementing the Abstract Factory interface

D Avoid using Abstract Factory and instantiate products directly in client code

💡 Hint

Think about how to keep product creation organized and decoupled for each family.

Creating a new Concrete Factory for each product family allows the system to scale by adding new families without changing existing code, preserving flexibility and adherence to the Open/Closed Principle.

❓ tradeoff

advanced

Tradeoffs of Using Abstract Factory Pattern

What is a common tradeoff when using the Abstract Factory pattern in system design?

A It reduces flexibility by tightly coupling client code to concrete classes

B It limits the number of product families that can be created

C It forces all products to share the same implementation

D It increases system complexity due to many interfaces and classes

💡 Hint

Consider the impact on code structure and maintenance.

While Abstract Factory promotes flexibility and consistency, it introduces more interfaces and classes, which can increase system complexity and maintenance effort.

❓ component

expert

Request Flow in Abstract Factory Pattern

In a system using the Abstract Factory pattern, what is the correct sequence of steps when a client requests a product from a factory?

A 1, 2, 4, 3

B 1, 3, 2, 4

C 2, 1, 3, 4

D 1, 2, 3, 4

💡 Hint

Trace the flow from client request to product usage.

The client calls the Abstract Factory (1), the Concrete Factory creates the product (2), the client receives the product without knowing its concrete class (4), and then uses the product via the Abstract Product interface (3).

Practice

1. What is the main purpose of the Abstract Factory pattern in system design?

easy

A. To create families of related objects without specifying their concrete classes

B. To allow direct instantiation of concrete classes

C. To enforce a single instance of a class

D. To simplify database queries

Solution

1. Step 1: Understand the role of Abstract Factory

   The Abstract Factory pattern is designed to create related objects without exposing their concrete classes.

2. Step 2: Compare options with the pattern's purpose

   To create families of related objects without specifying their concrete classes correctly describes this purpose, while others describe different patterns or unrelated concepts.

3. Final Answer:

   To create families of related objects without specifying their concrete classes -> Option A

4. Quick Check:

   Abstract Factory = Create related objects [OK]

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

Common Mistakes:

• Confusing Abstract Factory with Singleton pattern
• Thinking it creates only one object
• Mixing it up with Builder or Factory Method

2. Which of the following is the correct way to declare an Abstract Factory interface in a typical object-oriented design?

easy

A. var AbstractFactory = { create: function() { return ProductA; } }

B. class AbstractFactory { new ProductA(); new ProductB(); }

C. function AbstractFactory() { return new ProductA(); }

D. interface AbstractFactory { createProductA(): ProductA; createProductB(): ProductB; }

Solution

1. Step 1: Identify correct interface syntax

   Abstract Factory is usually declared as an interface with methods to create related products.

2. Step 2: Analyze each option

   interface AbstractFactory { createProductA(): ProductA; createProductB(): ProductB; } correctly declares an interface with creation methods. Options A, B, and C do not follow interface or abstract factory conventions.

3. Final Answer:

   interface AbstractFactory { createProductA(): ProductA; createProductB(): ProductB; } -> Option D

4. Quick Check:

   Abstract Factory interface = interface AbstractFactory { createProductA(): ProductA; createProductB(): ProductB; } [OK]

Hint: Abstract Factory uses interface with creation methods [OK]

Common Mistakes:

• Using concrete class instead of interface
• Returning product instances directly in constructor
• Confusing factory function with abstract factory interface

3. Given the following code snippet using Abstract Factory pattern, what will be the output?

class ModernFactory {
  createChair() { return 'Modern Chair'; }
  createSofa() { return 'Modern Sofa'; }
}
class VictorianFactory {
  createChair() { return 'Victorian Chair'; }
  createSofa() { return 'Victorian Sofa'; }
}
function client(factory) {
  console.log(factory.createChair());
  console.log(factory.createSofa());
}
client(new VictorianFactory());

medium

A. Victorian Chair\nVictorian Sofa

B. Modern Chair\nModern Sofa

C. Error: factory methods not found

D. undefined\nundefined

Solution

1. Step 1: Identify which factory is used

   The client function is called with new VictorianFactory(), so VictorianFactory methods will be used.

2. Step 2: Trace method calls and outputs

   VictorianFactory's createChair() returns 'Victorian Chair' and createSofa() returns 'Victorian Sofa'. These are printed.

3. Final Answer:

   Victorian Chair Victorian Sofa -> Option A

4. Quick Check:

   VictorianFactory output = Victorian Chair\nVictorian Sofa [OK]

Hint: Check which factory instance is passed to client [OK]

Common Mistakes:

• Assuming ModernFactory is used instead
• Confusing method names or return values
• Expecting errors due to missing interface

4. In the following Abstract Factory implementation, what is the main issue causing a runtime error?

class Factory {
  createProduct() {
    return new Product();
  }
}
class Product {}
const factory = new Factory();
const product = factory.createProduct();
console.log(product.name.toUpperCase());

medium

A. Missing interface declaration for Factory

B. Product class does not have a 'name' property, causing undefined access

C. Factory class cannot instantiate Product directly

D. createProduct method is not returning an object

Solution

1. Step 1: Analyze the Product class and usage

   The Product class is empty and does not define a 'name' property.

2. Step 2: Understand the console.log statement

   Accessing product.name returns undefined, and calling toUpperCase() on it causes a TypeError runtime error.

3. Final Answer:

   Product class does not have a 'name' property, causing undefined access -> Option B

4. Quick Check:

   Accessing missing property = Product class does not have a 'name' property, causing undefined access [OK]

Hint: Check if accessed properties exist on created objects [OK]

Common Mistakes:

• Thinking Factory cannot instantiate Product
• Expecting interface is mandatory at runtime
• Assuming createProduct returns null or undefined

5. You are designing a UI toolkit that supports multiple themes (Light and Dark). Using the Abstract Factory pattern, which design ensures that all UI components (Button, Checkbox) are consistent with the selected theme?

hard

A. Create Buttons and Checkboxes directly in client code based on theme

B. Use a single factory that creates default Buttons and Checkboxes ignoring theme

C. Create separate factories for Light and Dark themes, each producing themed Buttons and Checkboxes

D. Use a factory that creates only Buttons and let client create Checkboxes

Solution

1. Step 1: Understand the need for consistency

   Abstract Factory helps create families of related objects that match a theme or style.

2. Step 2: Evaluate design options

   Create separate factories for Light and Dark themes, each producing themed Buttons and Checkboxes creates separate factories for each theme, ensuring all components are consistent. Other options break consistency or delegate creation improperly.

3. Final Answer:

   Create separate factories for Light and Dark themes, each producing themed Buttons and Checkboxes -> Option C

4. Quick Check:

   Theme consistency = Separate factories [OK]

Hint: Use one factory per theme to keep components consistent [OK]

Common Mistakes:

• Mixing themes in one factory
• Creating components directly in client code
• Partial factory implementations missing products