• multiple choice questions from the test bank
• other questions, primarily coding
  • For all topics, you should be able to trace, analyze, and write Java code.
  • There may also be some short essay questions asking you to explain a concept, technique, etc.
  • Some of these questions will be coming directly from the lectures and labs; others will be new material.

The exam is cumulative with a focus on the topics since exam #1 (i.e., Lectures 5-9; Lecture 10 is NOT on the final): exception-handling, interfaces, class inheritance, recursion, collections, generics, and autoboxing, and the JCF

Exception Handling

• Alternatives to exception-handling: guardian methods, overloaded (trailer) return values, result objects
• Throwing, catching exceptions
• try/catch blocks

Interfaces

• Syntax, semantics, and purpose of an interface
• Implementing classes
• programming to the interface vs programming to the implementation/class
• Coding interface-level 'demo' apps
• Interface inheritance

Class Inheritance

• Independent implementation vs composition vs inheritance
  • is-a vs has-a
• Superclasses (parent) /subclasses (child)
  • Syntax, semantics, and purpose of inheritance
• protected data access
• up/downcasting
• overriding methods
  • vs overloading (compile-time polymorphism)
• superclass initialization

Polymorphism

• Rule of Polymorphism: method resolution is based on the (runtime/dynamic) type of the object and not the (static/compile-time) type of the receiver reference variable.

Abstract Classes and Methods

• Syntax, semantics, and purpose of an abstract class
• Skeletal class implementing part of an interface

Command-line Arguments

Recursion

• Escape clauses
• Recursive calls
• Recursion on integers, arrays, strings
  • You should be able to code simple recursive methods, including those covered in class and the notes
• Using lower/upper bounds for recursive methods involving arrays and strings
• Introducing a wrapper method between the user and the actual recursive 'workhorse' method

  int binsrch(int [] arr, int val) {return binsrch(arr, 0, arr.length-1);
  
  int binsrch(int [] arr, int lo, int hi, int val) {…}
  		

• Fibonacci, binary search, towers of hanoi
  • You need to be able to write the above methods (pseudocode is fine)

Collections

• vector
• Bounds-checking
• overflow
• capacity and size
• user-defined Exception classes
• resizeable containers
  • You should understand how an array can be 'resized' and in particular be able to code the method checkCapacity (pseudocode is fine).

    ArrayList

    • You should know the differences between an ArrayList and an array
    • creating
    • You should know the following methods: add(val), add(int index, Object val), get(int index), set(int index, Object val), remove(Object val), remove(int index) contains(Object val), size(), isEmpty()

    Generics & Autoboxing

    • You should understand how generics and autoboxing each simplify using colections like ArrayList
    • You should understand raw vs generic ArrayList
    • You should be able write the correct code to insert an object (e.g., a String) into a raw ArrayList as well as extract it (requiring downcasting) (and of course into a generic ArrayList of the correct type..
      • You should understand why putting thing into a (raw) collection is an upcast, while removing from a collection requires a downcast
    The Java Collection Framework (JCF)
    • Java's notion of the Collection, a List, a Set, and a Map interfaces.
    • The Iteratable and Iterator interfaces
    • How to iterate over a collection (without using the enhanced for loop) -- i.e., for (Iterator iter = …
    • superclasses/subclasses, superinterfaces/subinterfaces, classes implementing interfaces
    • Why putting thing into a (raw) collection is an upcast, while removing from a collection requires a downcast
    • The basics of various collections: ArrayList (resizeable array) Stack (LIFO), Queus (FITO), PriorityQueue (removed in priority order), TreeSet, HashSet, TreeMap, HashMap
    • The difference between the Hash and Tree versions of Set and Map
    • Using an ArrayList: add, get, iterator, set, addAll
    • Using a Map: containsKey, get, put, keySet
    -->

    All CodeLab exercises, Labs, and Lecture code

    • Labs 2-7 (remember Lab 6 — the maze — is optional)
    • And as always, all the labs and sample code in the lecture notes are fair game for questions (except Lab 6 -- the maze; though I might throw in an extra-credit question on that)e
    • and although I did say the exam is cumulative, I want to stress that you need to be able to code class definition.

    Test Banks of Questions

    • Lecture 05 - Exception Handling
    • Lecture 06 - Interfaces
    • Lecture 07 - Inheritance