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.
Understand and use concepts associated with cloning in Java. In
particular:
Describe the difference between shallow and deep copies.
Identify in code when a shallow copy is occurring.
Identify in code when a deep copy is occurring.
Write classes that correctly use of the Clonable interface.
Describe how Java's collection classes handle cloning.
Demonstrate the use of binary tree traversals (inorder, preorder,
postorder).
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.
I am responsible for all content posted on these pages; MSOE is welcome to share these opinions but may not want to.
