Design Patterns Questions

Vikas Vimal (Vikki)

Score: 🔥 175

Beginner

Took 1 month

Coding Principles

Design Patterns

66%

Questions Attempted

15 / 15

Correct Answers

Incorrect Answers

Points Earned

🔥 10

Question 1

Which of the following scenarios best exemplifies the use of the Strategy Pattern?

Creating a single, universal sorting algorithm for all data types.
Implementing different validation rules for a user input field based on context.
Representing a complex object structure as a hierarchical tree.
Logging system events to a file or a database based on configuration.

Explanation:

The Strategy Pattern shines when you have a family of related algorithms (validation rules), and the choice of which algorithm to apply can change dynamically based on the context (input field type, user role, etc.).

Question 2

Which of these is a common real-world analogy used to explain the Decorator Pattern?

A factory producing different types of objects.
A tree structure representing hierarchical relationships.
Adding toppings to a base coffee or ice cream.
A chain of objects processing a request sequentially.

Explanation:

Just like each topping adds a specific flavor or texture without changing the base product, decorators add functionalities without modifying the core object.

Question 3

In the Adapter Pattern, what is the 'Adaptee'?

The interface that the client expects to use.
The class that needs to be adapted to a different interface.
The class that implements the Adapter Pattern.
The client code that interacts with the adapter.

Explanation:

The 'Adaptee' is the existing class with an interface that needs modification to work with the client. The Adapter Pattern wraps around the Adaptee to provide the desired interface.

Question 4

Which of these is NOT a benefit of using design patterns?

Improved code readability
Increased code duplication
Enhanced code maintainability
Facilitated code reuse

Explanation:

Design patterns aim to reduce code duplication by providing reusable solutions, not increase it. They promote maintainability, readability, and reusability.

Question 5

In the Observer pattern, what does the 'subject' object do?

Observes the state of other objects.
Maintains a list of its dependents and notifies them of state changes.
Provides an interface for attaching and detaching observer objects.
Both B and C

Explanation:

The 'subject' is responsible for keeping track of its observers and providing methods for observers to register and unregister themselves. It also notifies the observers when its state changes.

Question 6

Which of these scenarios would be a suitable use case for the Decorator Pattern?

Creating different types of vehicles with varying features.
Implementing a logging system that can be added to different parts of an application.
Representing a family tree with complex relationships between members.
Managing the state of an object throughout its lifecycle.

Explanation:

You can create a base decorator for logging and then specific decorators for different log levels or targets, dynamically adding them to components as needed.

Question 7

Which of the following is NOT a typical category of design patterns?

Creational
Structural
Behavioral
Functional

Explanation:

The three primary categories of design patterns are Creational, Structural, and Behavioral. Functional programming is a paradigm, not a design pattern category.

Question 8

Can you have multiple Facade classes for a single complex subsystem?

No, the Facade Pattern restricts to only one Facade class.
Yes, you can have different Facades exposing tailored functionalities.
It's possible but not recommended as it violates the pattern's principles.
Multiple Facades can only be used with abstract classes, not concrete ones.

Explanation:

You can have multiple Facade classes for a subsystem, each providing a different level of abstraction or focusing on a specific subset of functionalities within that subsystem.

Question 9

How does the Command Pattern support the implementation of an 'undo' functionality?

By directly modifying the state of the application to revert changes.
By providing a mechanism to reverse the actions performed by a command.
By relying on the operating system's built-in undo functionality.
By preventing any actions from being executed in the first place.

Explanation:

A well-designed Command object can include not only the execution logic but also logic for how to undo its effect. This allows the application to revert changes step-by-step.

Question 10

Which of these is NOT a core component of the Strategy Pattern?

Strategy
ConcreteStrategy
Context
Factory

Explanation:

While a factory can be used to create Strategy objects, it's not a fundamental part of the Strategy Pattern itself. The core components are Strategy (interface), ConcreteStrategy (implementation), and Context (using the strategy).

Question 11

How does the Command Pattern achieve decoupling?

By directly connecting the object making the request with the object fulfilling it.
By introducing an intermediary object (the Command) between the invoker and the receiver.
By using inheritance to create specialized request handlers.
By relying on a central registry to map requests to their handlers.

Explanation:

The Command object acts as a link. The Invoker knows to execute the command, but not the specifics of what it does. The Receiver handles the action, but isn't directly tied to who made the request.

Question 12

What is the primary intent of the Factory Method pattern in software development?

To create objects directly within a class, exposing instantiation logic.
To delegate object creation to subclasses, promoting extensibility.
To enforce strict object creation rules through a central factory class.
To reduce code duplication by reusing object creation code across classes.

Explanation:

The core idea behind the Factory Method pattern is to define an interface for creating objects, but let subclasses decide which classes to instantiate. This promotes the Open/Closed Principle, allowing for extensibility without modifying existing code.

Question 13

How does the Strategy Pattern promote the Open/Closed Principle?

It allows adding new strategies without modifying the existing Context class.
It prevents modification of existing strategies, ensuring their integrity.
It promotes code reuse by allowing strategies to be shared across multiple contexts.
It reduces the need for inheritance, making the codebase more flexible.

Explanation:

The Open/Closed Principle advocates for systems that are open for extension but closed for modification. With the Strategy Pattern, you can introduce new algorithms (strategies) without altering the core Context class, adhering to this principle.

Question 14

How does the Decorator Pattern differ from traditional inheritance for extending functionality?

Inheritance allows for dynamic extension at runtime, while Decorator does not.
Decorator modifies the original class, while inheritance creates new subclasses.
Decorator provides more flexibility by allowing the combination of multiple functionalities at runtime.
Inheritance is generally preferred over Decorator due to its simplicity.

Explanation:

Unlike inheritance, which is static and defined at compile time, Decorator allows you to mix and match decorations dynamically during execution.

Question 15

What is a potential drawback of using the Factory Method pattern?

It can lead to increased code complexity, especially with many subclasses.
It violates the Open/Closed Principle, making code harder to modify.
It is not suitable for creating objects from abstract interfaces.
It prevents the use of dependency injection for object creation.

Explanation:

While powerful, Factory Method can make your codebase more intricate, particularly when dealing with a large number of concrete product types. Each new product often requires a corresponding concrete factory subclass.