Design Patterns Part 2

A general reusable solution to a commonly occurring software design problem.

An interface for creating objects, letting subclasses decide which class to instantiate.

Creates families of related or dependent objects without specifying their concrete classes.

Separates the construction of a complex object from its representation.

Specifies the kinds of objects to create using a prototypical instance, and creates new objects by copying this prototype.

Ensures a class has only one instance and provides a global point of access to it.

When you don't know beforehand the types or dependencies of the objects involved.

When you want to let users of your library extend its internal components.

When your code needs to work with different families of related products without relying on concrete product classes.

Separates the construction of a complex object from its representation. This allows for different representations of the same object.

Avoids 'telescopic constructors', creates various representations of an object (e.g., different houses), and builds composite objects.

Creates new objects by copying an existing prototype object.

Specifies the type of object to create and creates new ones by copying a prototype.

Separates object construction from its representation for complex objects.

A design pattern that restricts the instantiation of a class to one object and provides a global point of access.

Use when your code shouldn't rely on specific object classes, or when reducing subclasses that only differ in object initialization is desired.

Employ when a class requires a single shared instance across the program, like a database object.

Create a private constructor, and a static method to act as a constructor for creating the singleton instance.

1. When you don't know the exact types and dependencies of objects beforehand.
2. When you want to let users extend your library's components.
3. When reusing objects over creating new ones is desirable.

Specifies the kinds of objects to create, and creates new objects by copying a prototype.

1. When you don't want your code to depend on concrete classes of objects. 2. When you want to streamline creation of objects with different initial configurations.

Ensures that a class has only one instance and provides a global point of access to it.

1. When a class needs to have only one instance shared across your program. 2. For tighter control over global variables.

Provides a way to create families of related objects without depending on their concrete classes.

1. When your code needs to work with various families of related products.
2. When you have a class with multiple factory methods that conflict with its primary responsibility.
3. In a well-designed program, each class should have a single responsibility.

Separates the construction of complex objects from their representation, allowing for different representations.

1. To avoid complex constructors with many parameters.
2. To create different representations of the same product (e.g., different house styles).
3. To construct complex data structures like trees.

Specifies the types of objects to create using a prototypical instance and creates new objects by copying the prototype.

Reduces the need for subclasses that only differ in object initialization.

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