29 Questions
What is the primary goal of the Factory Method pattern?
To encapsulate object creation and allow subclasses to alter the type of objects created.
Which of the following patterns is most useful when you need to integrate incompatible classes?
Adapter
What is the main difference between the Factory Method and Abstract Factory patterns?
The Factory Method pattern is used when object creation is complex, while the Abstract Factory pattern is used when you need to create multiple related objects.
Which of the following patterns is most useful when you want to create objects with similar properties?
Prototype
What is the primary goal of the Builder pattern?
To separate the construction of complex objects from their representation.
Which of the following patterns is most useful when you want to separate object abstraction from its implementation?
Bridge
What is the primary goal of the Adapter pattern?
To convert the interface of a class into another interface that clients expect.
Which of the following patterns is most useful when object creation is expensive?
Prototype
What is the main advantage of the Abstract Factory pattern?
It provides a way to create multiple related objects.
What is the main purpose of the Composite design pattern?
To represent part-whole hierarchies and treat individual objects and compositions uniformly
When would you use the Decorator design pattern?
When you want to add additional responsibilities to an object
What is the main benefit of the Flyweight design pattern?
It reduces the cost of creating multiple objects by sharing common state
What is the primary purpose of the Proxy design pattern?
To provide a surrogate or placeholder for another object to control access to it
When would you use the Composite design pattern?
When you need to represent part-whole hierarchies
What is a key benefit of the Decorator design pattern?
It adds additional responsibilities to an object without affecting its external interface
When would you use the Flyweight design pattern?
When you need to create multiple objects with shared state
What is the primary purpose of the Decorator design pattern?
To add additional responsibilities to an object dynamically
When would you use the Proxy design pattern?
When you need to control access to an object
What is a key benefit of the Composite design pattern?
It allows clients to treat individual objects and compositions uniformly
In which scenario would you prefer to use the Factory Method pattern over the Abstract Factory pattern?
When the type of object to be created is determined at runtime.
What is a key difference between the Adapter pattern and the Bridge pattern?
The Adapter pattern modifies the interface of the adaptee, while the Bridge pattern separates the abstraction from the implementation.
When would you use the Builder pattern instead of the Factory Method pattern?
When the object creation process is complex or has multiple steps.
What is a key benefit of using the Prototype pattern?
It provides a way to create objects without specifying the exact class of object.
In which scenario would you prefer to use the Abstract Factory pattern over the Factory Method pattern?
When the client code wants to work with multiple, related objects.
What is a key benefit of using the Adapter pattern?
It enables the client code to work with objects that have incompatible interfaces.
When would you use the Builder pattern instead of the Prototype pattern?
When the object creation process is complex or has multiple steps.
What is a key difference between the Factory Method pattern and the Abstract Factory pattern?
The Factory Method pattern defines an interface for creating objects, while the Abstract Factory pattern defines an interface for creating families of related objects.
When would you use the Adapter pattern instead of the Bridge pattern?
When the client code needs to work with objects that have incompatible interfaces.
What is a key benefit of using the Factory Method pattern?
It provides a way to create objects without specifying the exact class of object.
Study Notes
Creational Patterns
Factory Method
- Provides an interface for creating objects, but allows subclasses to alter the type of objects created.
- Defines an interface for creating objects, but lets subclasses decide which class to instantiate.
- Useful when:
- Object creation is complex.
- You want to encapsulate object creation.
- You want to provide a way for subclasses to customize object creation.
Abstract Factory
- Provides a way to create families of related objects without specifying their concrete classes.
- Defines an interface for creating objects, but lets subclasses decide which class to instantiate.
- Useful when:
- You need to create multiple related objects.
- You want to encapsulate object creation.
- You want to provide a way for subclasses to customize object creation.
Builder
- Separates the construction of complex objects from their representation.
- Allows for step-by-step creation of objects.
- Useful when:
- Object creation is complex.
- You want to separate object creation from its representation.
- You want to provide a way for clients to customize object creation.
Prototype
- Creates a new object by copying an existing object (prototype).
- Useful when:
- Object creation is expensive.
- You want to create objects with similar properties.
- You want to provide a way for clients to customize object creation.
Structural Patterns
Adapter
- Converts the interface of a class into another interface that clients expect.
- Allows incompatible classes to work together.
- Useful when:
- You need to integrate incompatible classes.
- You want to provide a way for clients to use incompatible classes.
Bridge
- Separates an object's abstraction from its implementation.
- Allows for changes to the abstraction and implementation independently.
- Useful when:
- You want to separate object abstraction from its implementation.
- You want to provide a way for clients to customize object implementation.
Composite
- Composes objects into a tree structure to represent part-whole hierarchies.
- Allows clients to treat individual objects and compositions uniformly.
- Useful when:
- You need to represent part-whole hierarchies.
- You want to provide a way for clients to treat individual objects and compositions uniformly.
Decorator
- Adds additional responsibilities to an object dynamically.
- Allows for decorating an object without affecting its external interface.
- Useful when:
- You want to add additional responsibilities to an object.
- You want to provide a way for clients to customize object behavior.
Flyweight
- Reduces the cost of creating multiple objects by sharing common state.
- Useful when:
- You need to create multiple objects with shared state.
- You want to reduce the cost of creating multiple objects.
Proxy
- Provides a surrogate or placeholder for another object to control access to it.
- Useful when:
- You need to control access to an object.
- You want to provide a way for clients to access an object indirectly.
Creational Patterns
Factory Method
- Provides interface for creating objects, allowing subclasses to alter object type
- Defines interface for creating objects, letting subclasses decide which class to instantiate
- Useful for complex object creation, encapsulating object creation, and customizing object creation
Abstract Factory
- Creates families of related objects without specifying concrete classes
- Defines interface for creating objects, letting subclasses decide which class to instantiate
- Useful for creating multiple related objects, encapsulating object creation, and customizing object creation
Builder
- Separates construction of complex objects from their representation
- Allows for step-by-step creation of objects
- Useful for complex object creation, separating object creation from its representation, and customizing object creation
Prototype
- Creates new object by copying an existing object (prototype)
- Useful for expensive object creation, creating objects with similar properties, and customizing object creation
Structural Patterns
Adapter
- Converts class interface into another interface clients expect
- Allows incompatible classes to work together
- Useful for integrating incompatible classes and using incompatible classes
Bridge
- Separates object's abstraction from its implementation
- Allows for independent changes to abstraction and implementation
- Useful for separating object abstraction from its implementation and customizing object implementation
Composite
- Composes objects into tree structure to represent part-whole hierarchies
- Allows clients to treat individual objects and compositions uniformly
- Useful for representing part-whole hierarchies and treating individual objects and compositions uniformly
Decorator
- Adds additional responsibilities to an object dynamically
- Allows for decorating an object without affecting its external interface
- Useful for adding additional responsibilities to an object and customizing object behavior
Flyweight
- Reduces cost of creating multiple objects by sharing common state
- Useful for creating multiple objects with shared state and reducing creation cost
Proxy
- Provides surrogate or placeholder for another object to control access to it
- Useful for controlling access to an object and providing indirect access to an object
Creational Patterns
Factory Method
- Enables object creation without specifying the exact class of object
- Decouples object creation from specific class instantiation
- Useful for runtime object type determination and client code independence
Abstract Factory
- Creates families of related objects without specifying concrete classes
- Allows for runtime object type determination and client code flexibility
- Useful for working with multiple, related objects and dynamic object creation
Builder
- Separates object construction from representation for increased flexibility
- Enables step-by-step construction and object reuse
- Useful for complex object construction and multiple, independent object parts
Prototype
- Creates new objects by copying existing objects (prototypes)
- Reduces object creation costs and dependencies
- Useful for expensive object creation and similar object properties
Structural Patterns
Adapter
- Converts one object's interface to match another object's interface
- Enables incompatible object collaboration and interface modification
- Useful for interface incompatibility and implementation independence
Bridge
- Separates object abstraction from implementation for increased flexibility
- Enables implementation changes without affecting abstraction
- Useful for abstraction-implementation decoupling and multiple abstraction support
Composite
- Composes objects into trees for part-whole relationships and hierarchical structures
- Enables client code to work with objects of similar interfaces
- Useful for hierarchical object structures and similar object interfaces
Decorator
- Adds responsibilities to objects without affecting their external interface
- Enables object behavior extension without implementation changes
- Useful for behavior extension and multiple object relationships
Flyweight
- Shares common state among multiple objects to reduce creation costs
- Enables efficient object creation and similar property management
- Useful for objects with large shared state and similar properties
Proxy
- Provides surrogate objects for access control and additional functionality
- Enables object access control and implementation independence
- Useful for object access control, expensive object creation, and dependency management
This quiz covers creational patterns in design, including the Factory Method and Abstract Factory patterns. Learn about their uses and benefits in object-oriented programming.
Make Your Own Quizzes and Flashcards
Convert your notes into interactive study material.
Get started for free
