Cs307 Design Patterns 2

Front 1

Strategy

Back 1

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

Front 2

Observer

Back 2

Defines a one-to-many dependency between objects so that when one object changes state, all of its dependents are notified and updated automatically.

Front 3

Decorator

Back 3

Attach additional responsibilities to an object dynamically. This pattern provides a flexible alternative to subclassing for extending functionality.

Front 4

Factory Method

Back 4

Define an interface for creating an object, but let subclasses decide which class to instantiate. It lets a class defer instantiation to subclasses.

Front 5

Abstract Factory

Back 5

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

Front 6

Singleton

Back 6

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

Front 7

Command

Back 7

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

Front 8

Adapter

Back 8

Convert the interface of a class into another interface the clients expect. This pattern lets classes work together that couldn't otherwise because of incompatible interfaces.

Front 9

Façade

Back 9

Provide a unified interface to a set of interfaces in a subsystem. This pattern defines a higher-level interface that makes the subsystem easier to use.

Front 10

Template Method

Back 10

Define the skeleton of an algorithm in a method, deferring some steps to subclasses. It lets subclasses redefine certain steps of an algorithm without changing the algorithm's structure.

Front 11

Iterator

Back 11

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

Front 12

Composite

Back 12

Allows you to compose objects into tree structures to represent part-whole hierarchies. This pattern lets clients treat individual objects and compositions of objects uniformly.

Front 13

State

Back 13

Allow an object to alter its behavior when its internal state changes. The object will appear to change its class.

Front 14

Proxy

Back 14

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

Front 15

Bridge

Back 15

Decouple an abstraction from its implementation so that the two can vary independently.

Front 16

Builder

Back 16

Separates the construction of a complex object from its representation so that the same construction process can create different representations.

Front 17

Chain Of Responsibility

Back 17

Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request. Link the receiving objects and pass the request along the chain until an object handles it.

Front 18

Flyweight

Back 18

Use sharing to support large numbers of fine-grained objects efficiently.

Front 19

Interpreter

Back 19

Define a representation of the grammar for a language along with an interpreter that uses the representation to interpret sentences in the language.

Front 20

Mediator

Back 20

Define an object that encapsulates how a set of objects interact. It promotes loose coupling by keeping objects from referring to each other explicitly, and lets you vary their interaction independently.

Front 21

Memento

Back 21

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

Front 22

Prototype

Back 22

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

Front 23

Visitor

Back 23

Represent an operation to be performed on the elements of an object structure. This pattern lets you define a new operation without changing the classes of the elements on which it operates.

Front 24

Creational Patterns

Back 24

Focus on how objects are created and often involves isolating the details of object creation in such a way that you don’t have to make major changes to your code when you have to create a new type of object. Includes: Abstract Factory, Builder, Factory Method, Prototype, and Singleton.

Front 25

Structural Patterns

Back 25

Focus on how objects are interconnected, and attempts to ensure that changes in the system don't require changes in those connections. These patterns are often dictated by project constraints. Includes: Adapter, Bridge, Composite, Decorator, Façade, Flyweight, and Proxy.

Front 26

Behavioral Patterns

Back 26

Focus on objects that handle particular types of behavior in an application, and encapsulate processes such as interpreting a language, fulfilling a request, moving through a sequence (as an iterator), or implementing an algorithm. Includes: Chain of responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template method, and Visitor.

Front 27

Benefit of Design Patterns

Back 27

* Can speed up the development process by providing testing, proven development paradigms.
* Effective software design requires considering issues that may not become visible until later in the implementation. Reusing design patterns helps to prevent subtle issues that can cause major problems.
* Improves readability of the code for coders and designers who are familiar with the patterns.
* Provides patterns for solving problems on a level of abstraction above mere code reuse. Instead of "code reuse" you get "experience reuse."
* Provides a common language for designers.

Front 28

What are they

Back 28

General, reusable solution to commonly ocurring problems in software design.

A description or template for how to solve a problem that can be used in many different situations

Ways of organizing code to increase efficiency and provide greater OO Design.