CPSC 124, Fall 2001                        Information Sheet for Final Exam
---------------------------------------------------------------------------

    The final exam for this course takes place at 8:30 AM on Wednesday,
December 12, in our regular classroom.  The exam is cumulative, with
some emphasis on the material we have covered since the second midterm.
The new material on this test is Chapter 8 of the textbook and labs
12, 13, and 14.  The exam will be six pages long.  You can expect the usual
types of questions:

     (1) Programming:  You can expect several questions that ask you to
           write Java code segments or complete subroutines.  You might also
           be asked to write a complete program or a complete class.
           
     (2) Reading programs:  You can expect some questions that ask you to
           read some Java code and say what it does.  You might be asked 
           to show its output, or you might have to describe its purpose.
           
     (3) Definitions and short essays:  There will be some short, factual
           essay questions that ask you to define a term, explain a concept,
           or answer some specific question about Java or about programming.
           
     (4) Longer essays:  There will be one or two longer conceptual essays
           dealing with more theoretical questions about programming, how
           programs are designed, or other important concepts.
           
The final exam is worth 19% of the grade for the course.  In addition to
the exam, you also have a final programming project due, which is worth
10% of the course grade.  This project can be turned in at the final exam
or the following afternoon, December 13, before 4:00.

My schedule of open office hours is as follows:

         Friday,    December 7:    1:00 to 3:00
         Sunday,    December 9:    1:00 to 2:00
         Monday,    December 10:   1:00 to 3:00
         Tuesday,   December 11:  11:00 to 3:00
         Wednesday, December 12:   1:00 to 3:00
         Thursday,  December 13:   3:00 to 4:00

---------------------------------------------------------------------------

Here is a list of terms and ideas that we have covered since the last test:

   Data Structure                           Command-line arguments
   Array                                    Partially-full array
   Element of an array                      Dynamic array
   Base type of an array                    Vector
   Array index                              Adding an item
   ArrayIndexOutOfBoundsException                  to a partially-full array
   NullPointerException                     Linear search in an array
   Array notation -- []                     Binary search of a sorted array
   Length of an array                       Comparison of Linear
   Array initializer                               and Binary search
   Arrays AS objects                        Sorting
   Arrays OF objects                        Selection Sort
   Processing arrays with for loops         Insertion Sort
   Processing arrays with random access     Two-dimensional arrays
   Arrays as parameters                     Processing Two-D arrays
   Arrays as return values                  Parallel arrays
   Creating an array                        Correctness and Robustness

---------------------------------------------------------------------------

You should also review all the material that we covered earlier in the term.
You can review the information sheets for the first and second tests.  These
are available on-line, if you no longer have your copy.  Some of the most
important ideas from this material include:

   CPU                                      Style rules for programs
   Main memory (RAM)                        Algorithms
   Machine Language                         Pseudocode
   Compilers and Interpreters               Top-down and bottom-up design
   Syntax and Semantics                     Design using subroutines
   Variables and Types                      Bugs and debugging
   Primitive types (int, double, etc.)      Design using classes and objects
   Declaring and initializing variables     Object-oriented programming
   Assignment statements                    Inheritance and Polymorphism
   Input with TextIO                        Subclasses and superclasses
   Control structures (if, while, etc.)     The special variable "this"
   Subroutines                              Constructors
   Black boxes                              The "new" operator
   Interface and implementation             Static vs. instance members
   Formal and actual parameters             Java packages
   Return values                            Software "toolboxes"
   Local variables                          Public vs. private
   Named constants                          Interfaces
   Applets                                  State machines
   paint() and repaint()                    Events and listeners
   Graphics methods                         Event handlers
   Components and Layout                    Computer animation

   
