• Shuffle
    Toggle On
    Toggle Off
  • Alphabetize
    Toggle On
    Toggle Off
  • Front First
    Toggle On
    Toggle Off
  • Both Sides
    Toggle On
    Toggle Off
  • Read
    Toggle On
    Toggle Off

Card Range To Study



Play button


Play button




Click to flip

Use LEFT and RIGHT arrow keys to navigate between flashcards;

Use UP and DOWN arrow keys to flip the card;

H to show hint;

A reads text to speech;

20 Cards in this Set

  • Front
  • Back
This pattern is used to create concrete class instances without specifying the exact class type.

The essence of the Factory Pattern is to "Define an interface for creating an object, but let the subclasses decide which class to instantiate. The Factory method lets a class defer instantiation to subclasses." Factory methods encapsulate the creation of objects. This can be useful if the creation process is very complex, for example if it depends on settings in configuration files or on user input.
Abstract Factory
his pattern is used to create concrete class instances without specifying the exact class type. The Abstract Factory Pattern provides a way to encapsulate a group of individual factories that have a common theme.
A pattern used to maximize the sharing of objects resulting in reduced memory consumption.
This pattern insures that only a single instance of a given object can exist.
The builder pattern describe a way to separate an object from it's construction.
The same construction method can create different representation of the object.
Use the pattern in the following situations:

* You need to construct a complex object which has different representation.

* The algorithm for creating the object should be independent of the way the object's parts is assembled.
Convert the interface of a class into another interface clients expect. Adapter lets the classes work together that couldn't otherwise because of incompatible interfaces
Decouples an abstraction from its implementation so that the two can vary independantly.
Compose objects into tree structures to represent part-whole hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly.
Allows an objects behavior to be altered at runtime.

This change in behavior is accomplished by wrapping an object with a new object. This new wrapper object is the Decorator. The Decorator object will implement the same interface as the object being wrapped. Because the decorated object uses the same interface as an undecorated object, other parts of your system do not need to be aware of whether or not one or more decorations are in use.

The decorator (wrapper) can now alter the behavior of the object being wrapped by either completely replacing various methods or by altering the behavior of the methods of the object being decorated.
Used to provide a simpler interface into a more complicated portion of code.
Provides a Placeholder for another object to control access to it.
Chain of Responsibility
The chain of responsibility pattern is a way of communicating between objects.

As it’s name indicate a chain of handlers is built
and every handler in the chain is responsible to handle the passing request or deliver it to the next handler in the chain. In the end of the process the request is handled with a default or exceptional behavior.
The pattern helps to reduce coupling by freeing the object from knowing which handler will handle the request in the end.
Encapsulates a request as an object, thereby letting you parameterize clients with different requests, queue or log requests, and support undoable operations.
Provides a way to sequentially access aggregate objects without exposing the structure of the aggregate.
The mediator pattern encapsulate the interaction between a set of objects.
Allows you to save the state of an object externally from that object.
Allows a single object to notify many dependent objects that its state has changed.
Allows an object to change its behaviour when its internal state changes.
Allows multiple algorithms to be used interchangeably at runtime.
The visitor design pattern enables us to create new operations to be performed on an existing structure.