asdasd

Deep Copy

Called defensive copying because instead of making a reference you make a new object but with the same values, this way it's protected no matter what. A clone.

Idempotent

Calling it once is the same as calling it a million times.

Enum

enumeration type. Make small type safe values. No subclassing. Add's abstraction

Static array

size is set at compile time, its memory is permanetly bound, and its size is fixed.

Loop invariant

something which must be true before and after each iteration of a loop is run.

Class invariant

the loosest definition of a data structure that must always be true for the object to be legal.

binding time

the time at which a decision is made

Delegation

used in composition, when calling for the other classes, nesting a class in a class

Parameter passing

when the actual value is used in a method b/c it was called for.

Dynamic array

can be given at runtime if necessary.

UML

dashed = interface. Open Arrow=Compositon Closed =extends/implements aka dependency. If this class changes, it affects the other.

Immutable class

objects of the class cannot be changed.

open closed principle

open for extension, closed for modification

early binding time

(C++) simpler, quicker, not as flexible

****ing design patterns

Adapter, Iterator, template, Observer, Factory, Proxy

encapsulation

Also known as information hiding. Hides the implementation details in the Java class, so that the user must use the API to access the object.

behavioral subtyping

Any method that expects an object of type superclass must be able to use in its place an object of type subclass

Recursion

Base Case. Recursive Case. A recursive function calls itself in the body of the function, and works on a smaller set of data with each call of the function. Creates a new instance in the activation record with each call while an iterative function uses looping and works through the method only once.

Whitebox/Blackbox

Blackbox- does it do what it's supposed to do? Whitebox- Ensures that everything is excersized correctly.

Immutable class

Cannot be changed once instantiated. It really means that objects of that class cannot be changed, such as a string, u cant change that string now. Advantages- thread safe, simplicity. Disadvantages- bc if u want to change the object, youll have to make a copy. i.e. phonebooksTo create: Getters no setters, accessors no mutators.

Façade

Changes interface, but by denying access to certain. SQL. Wrapper. Hides a class in a class, restricts ****.

Adapter

Changes interface. 2->3 prong. Adapts it to be compatible with another program

Type Specific Code

Code written for different and specific data types. Overcome by writing generic mehods.

Iterator

Cohesive because to get data you don't know how the data is formatted etc. The iterator class will do that for you, thus dependency inversion principle. Has next() and hasNext() 'access elements of an object sequentially without exposing its underlying representation'

Shallow Copy

Create an alias, but if the original copy gets changed so does the new one, so usually not ideal.

dependency inversion principle

Depends upon abstraction, does not depend upon implementations

single responsibility principle

Each class should do one thing, and do it well

Extends vs. implements

Extends inherits the whole class. Implements is anlagous applies only to an interface. A class may extend a concrete or abstract class, but it implements an interface.

Inheritance vs Composition

Inheritance extends another class which means it implements, while composion allows classes to be made from other classes, ie a car (class) has an engine (class) and transmission (class). Composition: Class Fruit{}Class Apple{Private Fruit fruit = new Fruit():}

Selection vs Insertion sort

Insertion- picks element @ bottom of unsorted list and puts it's where specified. Slection sort picks the largest value and puts it at the beginning.

Factory

Is for creating objects. It's different from a constructor because it's more flexible. Decouple (cohesion) client from knowing implemention 2. Can return subtypes 3. Returns implementation unknown to client

Factoring

N!

abstract data type

Separates * What from How * Interface from Implementation * public from private by encapsulating implementation details. Information hiding is another term for encapsulation.

Observer

Separates User Interface (Observer from observable). (Type safe becaue something can't change a value while others are calling a value) Eliminate the main class from having to update of instances changing, decopling. Observable iterates throught obslist and calls update

Map

Stores a pair of values, a key and a value. Represented by <key,value>, sorted by key

Type Parameter

Used in generics to specify the data type used in the generic class.

Template

Used to set up the outline of an algoriyhem, but leaving the specific details in another class. Like having TemplateMethod, which doesn't change, and then having Sort(), which we can change later if we need to. Late binding

3 Level Architecture

User Interface, Model, Data. Level below doesn't know about level above

Pre/Post Condition

What must be true before/after

Polymorphism

a single variable used with several objects of related classes (at different times)

Interface

an abstraction, with no implementations, that describes what a client can do with an object of a given type

late binding time(Java)

flexible, slower, harder to debug, more complex (b/c it doesn't have to figure out what variables its using until its running the program)

Formal vs actual parameter

formal is a plceholder, actual is the actual value.