Design Patterns Questions

Георгий Кузнецов

Score: 🔥 40

Intermediate

Took 10 minutes

Coding Principles

Design Patterns

50%

Questions Attempted

10 / 10

Correct Answers

Incorrect Answers

Points Earned

🔥 5

Question 1

What is a key difference between a deep copy and a shallow copy in the context of the Prototype Pattern?

A deep copy is faster to execute than a shallow copy.
A shallow copy duplicates references, while a deep copy creates new instances for nested objects.
A deep copy is only applicable to immutable objects.
A shallow copy is preferred when you need to maintain object immutability.

Explanation:

This difference is crucial in Prototype. Deep copies prevent unintended side effects by ensuring that modifications on cloned objects don't impact the original prototypes or their nested members.

Question 2

How does the Composite pattern promote code reusability?

By encapsulating object creation logic.
By providing a common interface for interacting with simple and complex objects.
By allowing objects to change their behavior at runtime.
By ensuring that a class has only one instance.

Explanation:

The Composite pattern allows clients to treat individual objects and compositions of objects uniformly through a shared interface. This makes the code more flexible and reusable.

Question 3

In which scenario would the Prototype Pattern be LESS suitable?

When object creation is a lightweight operation.
When you have a large number of objects with minor variations.
When you want to avoid dependencies on concrete product classes.
When you need to create objects based on a configuration file at runtime.

Explanation:

If creating objects is already cheap and straightforward, the overhead of implementing the Prototype Pattern might outweigh its benefits. It shines when object instantiation is expensive.

Question 4

How does the Builder Pattern differ from using telescoping constructors?

Telescoping constructors are more readable for a large number of attributes.
The Builder Pattern is less flexible when dealing with optional attributes.
Telescoping constructors are preferred when the object construction is complex.
The Builder Pattern provides better control and clarity when building objects with many attributes.

Explanation:

Unlike telescoping constructors, which become unwieldy with numerous parameters, the Builder Pattern offers a structured approach for constructing objects with multiple attributes, particularly when many are optional.

Question 5

In the Flyweight pattern, what is the role of the 'intrinsic state'?

Data that is unique to each object and cannot be shared.
Data that is common to multiple objects and can be shared.
A factory method that creates and manages Flyweight objects.
An interface that defines operations for interacting with Flyweights.

Explanation:

Intrinsic state represents the shareable aspects of objects in the Flyweight pattern. This data is independent of the object's context and remains constant.

Question 6

Which real-world scenario is well-suited for the Composite pattern?

Managing a database connection pool.
Representing a file system with directories and files.
Implementing an undo/redo mechanism.
Creating a thread-safe singleton object.

Explanation:

A file system is a classic example of the Composite pattern. Directories can contain files (leaves) and other directories (composites), forming a tree-like structure.

Question 7

Which of these is NOT a common use case for the Prototype Pattern?

Creating objects with complex initialization logic.
Implementing a factory method pattern.
Maintaining a cache of frequently used objects for performance optimization.
Building systems with dynamic object creation based on user input.

Explanation:

While Prototype can be used alongside a factory method, they serve distinct purposes. Factory Method focuses on providing an interface for object creation without specifying the exact class, while Prototype deals with object creation through cloning.

Question 8

In the Builder Pattern, what is the role of the 'Director'?

It defines the abstract steps for building the object.
It constructs the actual object using the Builder.
It represents the complex object being built.
It provides an interface to access the built object.

Explanation:

The Director class in the Builder pattern is responsible for controlling the object construction process. It uses a concrete Builder instance to assemble the parts of the complex object in a specific order.

Question 9

What type of relationship does the Composite pattern leverage to represent the parent-child structure?

Dependency
Aggregation
Composition
Inheritance

Explanation:

The Composite pattern uses composition to build the tree-like structure. A composite object 'owns' its children, and the children cannot exist independently of the parent.

Question 10

How does the Iterator Pattern contribute to code maintainability?

By centralizing object creation logic.
By providing a global point of access to a single instance.
By encapsulating the iteration logic and abstracting the aggregate structure, making changes to either independently easier.
By defining a family of algorithms and making them interchangeable.

Explanation:

The decoupling provided by the Iterator Pattern enhances maintainability as modifications to the iteration process or the underlying collection's structure can be made without impacting each other.