Software Architecture Design Patterns

Question 1

Delegation

Answer 1

Let an object hand off work to a helper object; useful for sharing behavior without inheritance.

Question 2

Interface

Answer 2

Define a contract of operations without implementation; implemented by concrete classes to ensure consistency.

Question 3

Abstract Superclass

Answer 3

Factor out shared code into a base class with abstract methods for subclass-specific behavior.

Question 4

Interface and Abstract Class

Answer 4

Define an API via an interface and share default code via an abstract class.

Question 5

Immutable

Answer 5

Create objects whose state cannot change after construction; ensures thread-safety.

Question 6

Marker Interface

Answer 6

Empty interface used to tag classes with metadata for special handling (e.g., Serializable).

Question 7

Proxy

Answer 7

Provide a surrogate for another object to control access, add behavior, or lazy-load the real subject.

Question 8

Factory Method

Answer 8

Define an interface for creating an object, but let subclasses decide which concrete class to instantiate.

Question 9

Abstract Factory

Answer 9

Provide an interface for creating families of related objects without specifying their concrete classes.

Question 10

Builder

Answer 10

Separate construction of a complex object from its representation, allowing step-by-step creation.

Question 11

Prototype

Answer 11

Clone existing objects instead of creating from scratch; useful for performance-sensitive creation.

Question 12

Singleton

Answer 12

Ensure a class has only one instance and provide a global point of access to it.

Question 13

Object Pool

Answer 13

Reuse a set of initialized objects instead of creating/destroying them repeatedly.

Question 14

Filter

Answer 14

Process a stream of data through a chain of filters, each performing part of the work.

Question 15

Composite

Answer 15

Compose objects into tree structures to represent part-whole hierarchies; treat leaves and composites uniformly.

Question 16

Read-Only Interface

Answer 16

Expose only read operations to certain clients by providing an interface without mutators.

Question 17

Adapter

Answer 17

Convert the interface of a class into another interface clients expect by wrapping it.

Question 18

Iterator

Answer 18

Provide sequential access to the elements of an aggregate without exposing its representation.

Question 19

Bridge

Answer 19

Decouple an abstraction from its implementation so both can vary independently.

Question 20

Façade

Answer 20

Provide a simplified interface to a complex subsystem.

Question 21

Flyweight

Answer 21

Share fine-grained objects to minimize memory use by externalizing shared state.

Question 22

Dynamic Linkage

Answer 22

Load modules or classes at runtime, enabling pluggable architectures.

Question 23

Virtual Proxy

Answer 23

Act as a placeholder for an object that is expensive to create, instantiating it on demand.

Question 24

Decorator

Answer 24

Attach additional responsibilities to an object dynamically by wrapping it.

Question 25

Cache Management

Answer 25

Store results of expensive operations for quick retrieval to avoid repeated work.

Question 26

Chain of Responsibility

Answer 26

Pass a request along a chain of handlers until one handles it.

Question 27

Command

Answer 27

Encapsulate a request as an object, allowing parameterization, queuing, and undo.

Question 28

Mediator

Answer 28

Define an object that encapsulates how a set of objects interact, promoting loose coupling.

Question 29

Snapshot

Answer 29

Capture and externalize an object’s internal state without violating encapsulation.

Question 30

Observer

Answer 30

Define a one-to-many dependency so observers are notified when a subject’s state changes.

Question 31

State

Answer 31

Allow an object to alter its behavior when its internal state changes via state objects.

Question 32

Null Object

Answer 32

Provide an object with default do-nothing behavior to avoid null checks.

Question 33

Strategy

Answer 33

Define a family of algorithms, encapsulate each one, and make them interchangeable.

Question 34

Template Method

Answer 34

Define the skeleton of an algorithm in a method, deferring some steps to subclasses.

Question 35

Visitor

Answer 35

Represent an operation to be performed on elements of an object structure without changing their classes.

Question 36

Asynchronous Processing

Answer 36

Decouple request submission from execution using threads or queues for nonblocking operations.

Question 37

Single Threaded Execution

Answer 37

Serialize all access to a resource by funneling requests through a single thread.

Question 38

Guarded Suspension

Answer 38

Make a thread wait until a precondition is met before proceeding.

Question 39

Producer-Consumer

Answer 39

Coordinate producers and consumers via a shared buffer to decouple production from consumption.

Question 40

Lock Object

Answer 40

Use locks (mutexes) to enforce mutual exclusion around critical sections.

Question 41

Balking

Answer 41

Immediately reject an operation if an object isn’t ready, rather than blocking.

Question 42

Scheduler

Answer 42

Control when and which tasks or threads execute according to defined policies.

Question 43

Read/Write Lock

Answer 43

Allow multiple readers or one writer at a time to improve concurrency.

Question 44

Two-Phase Termination

Answer 44

Gracefully shut down threads by signaling then waiting for termination.

Question 45

Double Buffering

Answer 45

Use two buffers so one is read while the other is written, then swap for smooth flow.

Question 46

Future (Promise)

Answer 46

Represent a placeholder for a result that’s initially unknown, to be provided later.