Cs361 Final Exam

Front 1

Mediator Design Pattern

Back 1

-Behavioral
-reduces coupling
-classes communicate through Mediator

Hint 1

Mediator - Interface between Colleagues
Concrete Mediator - implements Mediator interface
Concrete Colleague - Communicates with other colleagues

Front 2

Prototype Design Pattern

Back 2

-Creational
-avoids subclasses
-avoid cost of creating 'new' objects

Hint 2

Prototype - interface that defines objects, is cloneable
ConcretePrototype - implements Protoype with specifics

Front 3

Abstract Factory Pattern

Back 3

-creational
-separates client from object creation
-client only deals with abstract object

Hint 3

Abstract Factory - interface client interacts with
Concrete Factory - method that creates new object
Abstract product - product interface
Product - object created by concrete factory

Front 4

Builder Design Pattern

Back 4

-creational
-Constructs complex object piece by piece
-often builds composite

Hint 4

Director - class with collection of builders, oversees creation
Builder - Interface for new objects
ConcreteBuilder - creates new objects

Front 5

Composite Design Pattern

Back 5

-structural
-group of objects to be treated as a single instance

Hint 5

Composite - Collection of components
Component - abstract for all components of the figure
Leaf - concrete component

Front 6

Decorator Design Pattern

Back 6

-structural
-adds behavior dynamically

Hint 6

Decorator - interface, wraps components
Component - abstract of object
Concrete Component - object
Concrete Decorator - implements Decorator

Front 7

Adapter Design Pattern

Back 7

-structural
-Translates from one interface to a compatible interface
-Used as a wrapper to allow classes to use incompatible interfaces

Hint 7

Adaptor - Interface that translates to the other interface
Adaptee - The incompatible interface
Client - Class that needs the translation

Front 8

Bridge Design Pattern

Back 8

-structural
-Allows different interface implementations to be used dynamically
-Abstracts the abstraction

Hint 8

Abstraction - defines the abstract interface & keeps reference to Implementor
Refined Abstraction - Extends interface defined by Abstraction
Implementor - defines the implementation to be used
ConcreteImplementor - Implements the Implementor

Front 9

Template Design Pattern

Back 9

-behavioral
-defines an algorithm in a skeleton class
-can change algorithm without affecting calling classes

Hint 9

AbstractClass - Defines algorithm
ConcreteClass - Implements algorithm

Front 10

Observer Design Pattern

Back 10

-behavioral
-event handling
-when a change occurs on subject, notifies all observers

Hint 10

Subject - Has list of Observers. Notifies them of changes
Observer - interface for Concrete Observer
Concrete Observer - notified of change, perform action

Front 11

Proxy Design Pattern

Back 11

-structural
-acts as relay
-Any action taken on proxy is relayed to original object

Hint 11

Subject - interface for RealSubject
RealSubject - actual object to interact with
Proxy - takes request/input, forwards to RealSubject

Front 12

Command Design Pattern

Back 12

-behavioral
-encapsulates a request as an object

Hint 12

Invoker - calls for a command
Receiver - Actual work done
Client - creates ConcreteCommand and sets Receiver
Command - interface for ConcreteCommand
ConcreteCommand - executes the command issued from the receiver

Front 13

Strategy Design Pattern

Back 13

-behavioral
-defines a group of algorithms
-allows to interchange dynamically

Hint 13

Context - contains collection of Strategies to call dynamically
Strategy - algorithm interface
ConcreteStrategy - implementation of the Strategy

Front 14

Facade Design Pattern

Back 14

-structural
-provides simple interface for a library or API

Hint 14

Facade - Interface to various packages
Package - library or function

Front 15

Differences between:
Adapter, Bridge, Decorator,Facade

Back 15

Adapter-converts one interface to another
Decorator-dynamically adds responsibility to interface by wrapping
Facade-provides a simplified interface
Bridge-dynamically change interface implementations

Front 16

Object Constraint Language

Back 16

- Constraints in have no side effects
- No flow control
- All statements return boolean
- evaluated in specific context (method or class)

Front 17

4 Types of Transformations

Back 17

1.Refactoring
2.Forward Engineering
3.Reverse Engineering
4.Model Transformation

Front 18

Refactoring

Back 18

Restructure code without affecting external behavior

Front 19

Forward Engineering

Back 19

Implementing design model in code
-Map inheritance, associations, contracts to exceptions, models to tables

Front 20

Model Transformation

Back 20

-Collapse Objects
-Delay expensive computations

Front 21

Reverse Engineering

Back 21

Deconstruct code to learn what it does and make it do things it wasn't designed to do