At the time of the Midterm Exam, a student should be able to:

• Understand the semantics of polymorphism and inheritance. In particular:
  • Describe the concept of polymorphism.
  • Describe the concept of inheritance.
  • Explain the implications of overriding a method in an inherited class.
  • Identify legal and illegal casts from a derived class to a base class and vice versa.
  • Describe what happens at runtime if an illegal cast is encountered.
• Understand the concepts of Interfaces and Abstract Classes. In particular:
  • Describe the concept of an interface.
  • Describe the concept of an abstract class.
  • Explain when it makes sense to provide some implementation in an abstract class, even though the call is not instantiable.
  • Demonstrate how to derive a concrete class from an abstract class.
  • Demonstrate how to create a class that implements an interface.
  • Explain why programming to an interface is better than programming to an implementation.
• Interpret and write Java classes that use generics.
• Understand the meaning of asymptotic time complexity analysis. In particular:
  • Describe the value of big-oh notation.
  • Describe the limitations of big-oh notation.
  • Provide a definition for big-oh notation.
  • Be able to analyze the time complexity of simple algorithms with loops and conditionals.
  • Be able to analyze the time complexity of simple recursive methods.
  • Be able to compare the time complexity of two alternate algorithms.
  • Be able to analyze the time complexity of a program with multiple simple method calls with known time complexity.
• Interpret and write Java code using the ArrayList and LinkedList classes.
• Understand the underlying organization of the following data structures: array-based-list, double/singly-linked-list, stack, and queue. In particular:
  • Implement the basic methods of an array-based data structure.
  • Implement the basic methods of a singly-linked-list data structure.
  • Explain how the stack and queue data structures are typically implemented.
• Describe and explain the time complexity for inserting, finding, and deleting items to/from the following data structures: ArrayList, LinkedList, stack, and queue.
• Enumerate and explain the methods available in the pure stack and pure queue interfaces.
• Define the term adaptor class and be able to implement a simple adaptor class, e.g., stack, queue.

At the time of the Final Exam, a student should, in addition to the above, be able to:

• Understand and apply recursion in algorithm development.
• Demonstrate the use of binary tree traversals.
• Define a collision as it relates to hash tables and describe ways of coping with collisions.
• Interpret and develop simple hashing functions.
• Interpret and write Java code using the TreeMap, TreeSet, HashMap and HashSet classes.
• Understand the underlying organization of the following data structures: binary trees, binary search trees, balanced binary search trees and hash tables. In particular:
  • Implement the basic methods of a binary search tree data structure (add, remove, contains).
  • Implement the basic methods used for balancing a binary search tree data structure (leftRotate, rightRotate).
  • Explain how the TreeMap and TreeSet data structures are typically implemented.
• Describe and explain the time complexity for inserting, finding, and deleting items to/from the following data structures: TreeMap, TreeSet, HashMap, and HashSet.