Structural Design Patterns Quiz

<p>To ensure only specific clients can access the service. (C)</p> Signup and view all the answers

<p>It is the actual implementation that the Proxy delegates to. (D)</p> Signup and view all the answers

<p>When an existing class interface is incompatible with your code. (A)</p> Signup and view all the answers

<p>To enable assigning extra behaviors to objects at runtime (B)</p> Signup and view all the answers

<p>To allow for concrete implementations to vary at runtime. (A)</p> Signup and view all the answers

<p>Subsystem Classes (C)</p> Signup and view all the answers

<p>To handle collections with a simple interface while hiding complexity. (C)</p> Signup and view all the answers

<p>When it's awkward or not possible to extend behavior using inheritance (D)</p> Signup and view all the answers

<p>Bridge (C)</p> Signup and view all the answers

<p>When traversing a simple linear list of objects. (C)</p> Signup and view all the answers

<p>A minimal interface to a complex subsystem (D)</p> Signup and view all the answers

<p>When reuse of shared objects is crucial to save memory (D)</p> Signup and view all the answers

<p>It allows for the creation of multiple independent class hierarchies. (B)</p> Signup and view all the answers

<p>To enhance objects with new behavior (C)</p> Signup and view all the answers

<p>Composite (C)</p> Signup and view all the answers

<p>When you require a simplified interface to a complex system (B)</p> Signup and view all the answers

<p>To provide functionality that is being adapted. (A)</p> Signup and view all the answers

<p>It optimizes memory usage by sharing objects (C)</p> Signup and view all the answers

A design pattern that allows objects with incompatible interfaces to work together.

Includes Target (client's expected interface), Adaptee (original incompatible class) and the Adapter (bridge between them).

A design pattern that decouples an abstraction from its implementation. Allows switching implementations at runtime.

Includes Abstraction, Refined Abstraction (Implementation), Implementor, and Concrete Implementor to achieve decoupling.

Treats individual objects and groups of objects uniformly. Hides complexity in a collection.

Useful when you want to treat a hierarchy of objects as a single object, to reduce code duplication for traversal.

Design patterns organizing classes and objects into larger structures.

Focuses on interactions between objects.

A design pattern that minimizes memory usage by sharing objects that are otherwise identical. It effectively reuses existing objects for similar requests rather than repeatedly creating new ones.

In a system where many objects have shared data, store the shared data in a centralized location and have objects reference that shared data instead of storing it individually.

A design pattern where an object acts as an intermediary or placeholder for another object, controlling access to that object.

When an object is expensive to create or maintain, use a proxy to delay its creation until it's absolutely needed. This can improve performance, especially if the object is rarely accessed.

A proxy object can handle communication with a remote object, providing a simplified local interface for the client. It hides the complexity of remote interactions.

A design pattern that allows adding extra behaviors to objects at runtime without modifying the original object's code. It's used when inheritance is inconvenient or impossible.

The common interface that both the decorated objects and decorators implement. It defines the methods that can be decorated.

The actual object to be decorated. It implements the Component interface.

An object that wraps another object (Concrete Component) and provides additional functionality.

Specific types of decorators that implement enhancements like luxury fittings or bulletproofing in the plane example.

A design pattern that provides a simplified interface to a complex subsystem, hiding its intricate details. It simplifies access to a complex system.

The collection of complex classes that the Facade pattern simplifies. They represent the intricate parts of the subsystem.