- Fields, static fields, local variables (Lecture 2)
- Explain the difference between a local variable, a field, and a static field
- Execute Java code while maintaining the heap, stack, and static area

- Classes and interfaces, is-a relationship (Lecture 5 and Lecture 6)
- Be able to determine when one type is-a 'nother type.
- Determine whether a method signature is an appropriate implementation of an interface

- Access modifiers and encapsulation (Lecture 3)
- Know the meaning of public, private, and protected
- Explain why these are important and when to use them

- Subclasses and overloading (Lecture 7)
- Understand the difference between overloading and overriding
- Execute code that has uses overridden methods

- Exceptions (Discussion 3)
- Be able to execute code that throws and catches exceptions

- Generics (Lecture 7 and lecture 8)
- Understand the meaning of
`class C<E>`

- Be able to use generic types
- Be able to determine the is-a relationship for generic types with wildcards

- Understand the meaning of
- Standard library
- Be comfortable with the following types from the standard library:
- List
, Map , Comparator , Iterator , String, Object

- List

- Be comfortable with the following types from the standard library:

- Recursion (Lecture 9 and lecture 10)
- Be able to develop and execute recursive algorithms

- Array diagrams (Discussion 6)
- Know the meaning of
`a[i..j]`

and`a[i..j)`

- Understand array diagrams

- Know the meaning of
- Loop invariants (Lecture 15 and discussion 6)
- Know the four loopy questions
- Use them to develop an algorithm from a precondition, postcondition, and invariant
- Given a precondition and a postcondition, produce a loop invariant that generalizes them

- Class invariants
- Develop classes by writing down representation invariants (or class invariants)

- big-O notation
- Know the meaning of "f is O(g)"
- Know the relationship between O(1), O(log n), O(n), O(n^2), O(n^k), O(2^n)
- Be able to analyze algorithms containing loops
- Be able to analyze simple divide-and-conquer algorithms (e.g. binary search and mergesort)

- Linked lists
- Understand singly- and doubly-linked lists
- Be able to write basic recursive and iterative algorithms to traverse lists

- Heaps
- Know the heap invariant
- Understand how to store a heap in an array

- Arrays
- Know when use of arrays (or ArrayLists) is appropriate

- Hashtables
- Understand the basic layout and operations of a hashtable.
- Be able to insert and find elements in a hashtable (including resizing)

- Adjacency list/matrix
- Be able to draw an adjacency list and an adjacency matrix for a graph
- Understand the tradeoffs between these

- Binary trees, binary search trees, abstract syntax trees
- Know the binary search tree invariant
- Be able to find an element in a binary search tree
- Be able to perform pre- post- and in-order traversal

You should be able to write down the specifications and invariants for the following algorithms, and be able to execute them "by hand":

- Sorting
- Insertion, Selection, Quick, Merge

- Graph traversals
- Breadth-first search, Depth-first search

- Dijkstra's algorithm
- Prim's algorithm
- Finding a coloring
- Topological sort