In addition to displaying your mastery of Java basics (syntax,
object-oriented concepts) as covered on Quiz 1, you should show your
understanding of key concepts covered since them, particularly
abstract classes, interfaces, lists (the ADT, the Java interface and
implements, and how to implement lists with arrays), and enums.

More OOP
- You should understand method overloading and overriding
- You should understand abstract classes and methods, specifically
  why a class or method should be declared abstract
- You should be able to write an equals() method for a class... and
  you should know the difference between == and equals()

Interfaces
- What goes in an interface?
- How do you implement an interface?
- Comparable
  - what does the compareTo method return?
  - You should be able to write a compareTo method for a class 

List
- Understand the basic definition of a list: an ordered collection of
  items.  Items are indexed.  Duplicates (typically) are allowed.
- Know the key List methods, specifically their signatures and their
  behaviors. Methods you should know include:
  - add (at end), add (at a specific position)
  - remove (a specific element), remove (from a specific position)
  - get, set
  - indexOf, contains
  - size

You should be able to write code that uses key methods from the Java
List interface.

  - You should be able to declare and use a list that contains elements of
    a specific type, for example:
      List<Animal> pets = new ArrayList<Animal>();

  - You should know that list indices begin with 0.

  - You should be able to iterate over a list
    - You should know how to write a for-each loop and how to use an
      explicit Iterator, and you should know when each is appropriate

You should be able to implement the List interface using arrays

  - First, you need to be able to use arrays. Recall all the basic
    skills: define array types, allocate memory, initialize, set and
    get values, iterate over arrays.

  - You should be able to implement any of the List methods mentioned
    above.
    - You should know what exceptional conditions these methods should
      check for and what exceptions they might have to throw
    - You should know what the "hard parts" are when using arrays to
      implement lists... and know how to do the hard parts
    - You should be able to evaluate the ease/difficulty of
      implementing different list methods with arrays.

Enums
  - You should know how to define and use a simple enumerated type