Design Pattern Design Patterns Flashcards

24 sample cards from the Design Patterns deck

Sampled from the end of the deck, so these are different cards from the ones shown on the syllabus page.

1. What is the intent of the Flyweight pattern?

   Use sharing to support large numbers of fine-grained objects efficiently by sharing common state among them.

2. In Flyweight, distinguish intrinsic state from extrinsic state.

   Intrinsic state is shared, context-independent data stored inside the flyweight; extrinsic state is context-dependent data supplied by the client and passed in on each operation (not stored).

3. Which pattern would you use to reduce memory when rendering thousands of tree objects that share the same texture and mesh?

   Flyweight, storing the shared texture/mesh as intrinsic state and passing per-tree position/scale as extrinsic state.

4. What is the intent of the Proxy pattern?

   Provide a surrogate or placeholder for another object to control access to it.

5. Name four common variants of the Proxy pattern.

   Virtual proxy (lazy creation of expensive objects), remote proxy (represents an object in another address space), protection proxy (controls access rights), and smart reference/smart proxy (adds actions like reference counting or locking).

6. How do Proxy and Decorator differ in intent despite similar structure?

   Both wrap an object with the same interface, but Proxy controls access to the object (often managing its lifetime/location), while Decorator adds new responsibilities/behavior.

7. What is the intent of the Chain of Responsibility pattern?

   Avoid coupling the sender of a request to its receiver by giving multiple objects a chance to handle the request, passing it along a chain until one handles it.

8. In Chain of Responsibility, what happens if no handler in the chain handles the request?

   The request falls off the end of the chain unhandled (it may be ignored or trigger a default action); handling is not guaranteed.

9. What is the intent of the Command pattern?

   Encapsulate a request as an object, thereby letting you parameterize clients with different requests, queue or log requests, and support undoable operations.

10. Name the participant roles in the Command pattern.

    Command (interface with execute), ConcreteCommand, Receiver (does the work), Invoker (triggers the command), and Client (creates and configures commands).

11. Which method is typically added to a Command interface to support undo functionality?

    An 'undo()' (or 'unexecute()') method that reverses the effect of the corresponding execute().

12. What is the intent of the Interpreter pattern?

    Given a language, define a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language.

13. In Interpreter, what is the distinction between a TerminalExpression and a NonterminalExpression?

    A TerminalExpression implements interpretation for a leaf/atomic grammar symbol; a NonterminalExpression represents a grammar rule composed of other expressions and interprets by recursively invoking its children.

14. What is the intent of the Iterator pattern?

    Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation.

15. What is the difference between an internal (passive) and an external (active) iterator?

    With an external iterator the client controls the iteration and explicitly requests the next element; with an internal iterator the iterator controls iteration and applies a supplied operation to each element itself.

16. What is the intent of the Mediator pattern?

    Define an object that encapsulates how a set of objects interact, promoting loose coupling by keeping objects from referring to each other explicitly.

17. How does Mediator change the communication topology among colleague objects?

    It converts a many-to-many web of direct references between colleagues into a hub-and-spoke (star) topology where all colleagues communicate only through the mediator.

18. What is the intent of the Memento pattern?

    Without violating encapsulation, capture and externalize an object's internal state so that the object can be restored to this state later.

19. Name the three participants of the Memento pattern.

    Originator (creates and restores from mementos), Memento (stores the originator's internal state), and Caretaker (keeps mementos but never inspects their contents).

20. In Memento, why must the Caretaker treat the memento as opaque?

    To preserve encapsulation: only the Originator may read or modify the memento's stored state; the Caretaker just holds and returns it, never examining its internals.

21. Which behavioral pattern is the natural basis for implementing undo/redo history, and what role stores each snapshot?

    The Memento pattern; the Caretaker stores a stack of Memento snapshots produced by the Originator, restoring one to undo.

22. Which two patterns are commonly combined so that each queued Command object can be undone by saving state in a Memento?

    Command and Memento: the Command captures the Receiver's prior state in a Memento before executing, enabling undo.

23. Which single creational pattern is inherently limited to producing one instance, and which produces whole families of related objects?

    Singleton produces exactly one instance; Abstract Factory produces families of related objects.

24. Give one concrete example use case each for Facade, Flyweight, and Chain of Responsibility.

    Facade: a simple API wrapping a complex compiler/subsystem. Flyweight: sharing glyph objects in a text editor. Chain of Responsibility: an event-handling or middleware pipeline where each handler may process or pass the event on.

What this deck covers

Design Patterns flashcards FAQ