CS 2102 (B12): Object-Oriented Design Concepts
Midterm Prep Guide

What Should You Expect?

• The exam is pencil-and-paper. You may not use a computer.

• The exam is self-contained. You will not be asked to recall any specific problem from homework or labs.

• You will not be expected to write much code on the exam. You may be asked to write interfaces and (abstract) classes (fields and constructors). You will not be asked to write large methods. You may be asked to fill in the blanks in a partially-written method.

• You will not be graded on the details of Java syntax. You should know what info goes where (i.e., where fields go, what goes into each of interfaces and classes, how to distinguish abstract classes from non-abstract classes). You will not lose points for a missing semicolon, unbalanced braces, or other minor details as long as indentation/punctuation makes it clear what goes where.

What You Can Bring

You may bring a single sheet of paper with whatever notes, examples, comments, etc that you wish. You may use both sides of the paper. Typeset or handwritten is fine. The exam is otherwise closed-book, closed-notes.

You may not share paper notes with others during the exam.

What You are Expected to Know

• When to create each of classes, abstract classes, and interfaces
• What distinguishes classes, abstract classes, and interfaces
• The difference between abstract data types and data structures
• For the various data structures we've studied, their operations, shapes and invariants, and their efficiency at each of their core operations. The data structures covered on the exam are lists, sorted lists, binary trees, binary search trees, AVL trees, and heaps (Monday's topic). You have also been exposed to stacks, queues, and priority queues (for which you should know the operations, but not anything about efficiency).
• The relationships between Java constructs we have covered so far, abstract data types, and data structures.
• How to test against purpose statements for methods, ADT axioms, and data structure invariants.
• How to use Java's access modifiers to protect variables and methods
• How to encapsulate code

Exams from Previous Offerings

I do not have the exam answers written out to post, but feel free to go over these problems in anyone's office hours.

• midterm from B-term 2010: you should be able to answer all questions from this exam (this used more conventional grading, so ignore how grades were done on this exam).

• midterm from B-term 2011: you should be able to answer questions 1 and 2; the material for question 3 is not covered on your midterm. This exam uses outcome grading.

• final from B-term 2011: you should be able to answer question 1; the material for questions 2 and 3 is not covered on your midterm. This exam uses outcome grading.

Literal Instructions from First Page of Exam

You have 50 minutes to complete the problems on the following pages. There should be sufficient space provided for your answers.

If a problem asks you to create a class hierarchy, we are looking for the interfaces, classes, and abstract classes that you would create for the problem. In particular:

• Include implements and extends statements
• Include field names and types
• Include method headers (names, return type, and input parameter types)
• Full credit requires that all types and implements/extends relationships are clear. Be sure your work is clear if you use class diagrams instead of Java syntax.
• You may omit constructors
• You may omit method bodies unless a question asks otherwise
• You may omit the Examples class (examples of data and test cases) unless a question asks otherwise