final review flashcards.txt

• Class (static) variables are shared by all members of the class. They cannot access instance members of the class.
• Instance variables are variables dependent on a specific instance of the class.

• variableType variableName;
• i.e., String firstName;

• static variableType VARIABLE_NAME;
• i.e., static double PI_TO_TWO = 3.14;

• The public visibility modifier (for classes, methods and data fields) denotes that they can be accessed from any other classes.
• The private visibility modifier makes methods and data fields accessible *only* from within its own class.

To give a client more initializing options.

The designated constructor initializes the object most completely. The convenience constructors should call the designated constructor. A no-arg constructor is an example of a convenience constructor.

Getters (to read state) and setters (to update state) are used to access instance variables (ivars) and class variables (cvars). You should use them whenever you need access to an ivar/cvar. Doing so reduces maintenance, avoids redundancy and offers flexibility.

Unified Modeling Language

private

public

static (class)

abstract

interface

composition (object is fully owned)

aggregation (object is shared)

generalization (inheritance)

Practice this!!!

• Reusability - reuse code from parent class
• Extensibility - Use subclasses to extend the functionality superclasses (i.e., student -> graduate or undergraduate. Both share common traits, but have unique traits that student doesn't have and other subclasses don't require).

• public class superClass {}
• public class subClass extends superClass{}

Practice this!!!

inheritance

composition

Polymorphism allows for the proper method (super- or sub-class) to be called at runtime (because of dynamic -runtime- binding).

• The method must exist in both the subclass and the superclass with the same name and the same argument lists (number and type).
• The return type of both methods must match.
• Don't declare the superclass private or final (or static if the classes are in the same file).

An object can be declared as the type of the superclass, but be of a subclass type. For example, if you create an array of Students, they can be Graduate or Undergraduate type objects. You can return the actual type of an object at runtime using instanceof. (if ( person1 instanceof undergraduate ))

• Declared type - determines if a method can be called
• Actual type - Provides actual implementation

Polymorphism offers the desired flexibility that is needed in OO environments. It also allows code to be easily modified to allow for future needs.

• Constructor: super() - for no-arg constructor
• super(args)

When you are handling a checked exception, you must declare a checked exception if the method might throw it (e.g., throws FileNotFoundException). Then, you enclose the code that could throw the exception in a try block and handle the exception in the catch block.

locally

caller

The error is caught to prevent errors in execution, but the exception is re-thrown to the caller to allow any clean-up that needs to take place as a result of the error. Otherwise the called method would terminate the program.

If one of the statements inside a try statement is caught, Java skips the remaining statements in the try block and trys to handle the exception. Each catch statement (on the stack of calling methods) is examined in turn to see if the caught exception is handled in that catch block. If so, it is executed. If nhot, it proceeds up the stack.

ASCII requires 1 byte for each character, while binary can store data using fewer bits.

is not

is

efficient

• FileXXXStream - bytes
• DataXXXStream - primitive/String
• BufferedXXXStream - buffered bytes
• ObjectXXXStream - objects, primitives

nesting of streams

It allows class hierarchies to be read to/written from disk.

public class Stack {}

public void display(T[] list)

• *compile time error checking
• *flexibility

No. They are replaced by Java at runtime with concrete classes.

No. Primitive types must be wrapped (or boxed). For example, int becomes Integer.

Converts a primitive type to an object (e.g., int to Integer).

Converts an object to a primitive type (e.g., Integer to int).

• *provides backward compatibility
• *Raw syntax is rewritten to use generics
• *generic bounding wildcards (?, ? extends)

Collections and maps

• Set: unordered no duplicates
• List ordered dups allowed
• Queue ordered (FIFO) dups allowed

A map is composed of key/value pairs. There can be no duplicates (due to the hashing algorithm) and search is very fast.

~~~~~

• *array implementation
• *dynamically increases
• *maintains order of insertion
• *requires shifting during insertions/deletions

• *linked implementation
• *dynamically increases/decreases
• *maintains order of insertion
• *does not require shifting durint insertions/deletions

When classes don't impelement the Comparable interface, and when the classes are not the same but share common characteristics.

• *can compare in a non-natural order
• *can compare dissimilar objects
• *offers compare method

• *LIFO
• *reverses order of insertion (when popped)
• *push and pop ONLY at the TOP of the stack

• *FIFO
• *maintains order of insertion
• *insert at the end of the queue (push)
• *remove at the front of the queue (pop)

• *insert at the end of the queue
• *remove at the front of the queue
• *order of insertion not maintained (due to prioritization)
• *value with highest priority moves to the front of the queue

• *each node is linked to the next one
• *order of insertion is maintained
• *uni-directional traversal (head to tail)

• *queue, but with
• *bi-directional traversal (head to tail and tail to head)

• *no duplicates
• *insertion order not maintaines
• *can be searched fast

It uses a hashcode for fast searching.

It maintains order of insertion.

It provides sorting order (increasing or decreasing)

• *key-value pairs
• *key is usually a string
• *value can be any object
• *no duplicates
• *fast searches

It uses a hash code for fast searching

It maintains insertion order.

It provides sorting order (increasing or decreasing).

small

n - 1, where n is the number of items in the set to be sorted

quick exit. It knows when it is finished; the others have to sort to the end of the set to ensure completion.

recursive

large

external data

binary tree

• *Build heap, remove root successively
• *add to the bottom, rebuild heap
• *remove root, rebuild heap

• *sorts n values, each m digits in length
• *starts with least significant digit (lsd) and progresses to most significant digit (msd)
• *uses value-based bins to distribute digits