CPSC 124, Fall 2001                       Information Sheet for Second Test
---------------------------------------------------------------------------
     The second test in this course will be given in class on Monday, 
November 12.  It covers material from Chapters 4 thorough 7 of the
text and from Labs 5 through 11.  The format of the test will be
similar to the first test.  You should expect a mixture of programming
questions and essay-type questions.
     Any questions that ask you to WRITE Java code will be based on
Chapter 4 (subroutines), Chapter 5 (objects and classes), or on the
basic use of the Graphics class for drawing pictures.  You should
be able to READ Java code that uses material from Chapter 6 (except
Keyboard and Focus events) and figure out what it does.  From Chapter 7,
you should be familiar with the important concepts, so that you can
discuss them and answer questions about them.  There will be NO questions
related to HTML, Threads, Frames, or nested classes.  That is, you are
really only responsible for sections 1 through 4 of Chapter 7.
Important terms and ideas for this test include:

   Black box                                 Object-oriented programming
   Black box principles                      objects
   interface and implementation              classes
   subroutines                               static vs. non-static
   writing subroutines                       instance of a class
   calling subroutines                       instance variable
   parameters                                instance method
   formal parameters                         how to write a class
   actual parameters                         class as "types"
   local variables                           pointers
   functions                                 null
   the "return" statement                    the heap
   returning a value from a function         assignment operator for objects
   software toolbox                          the == operator for objects
   API                                       constructors
   Java packages                             writing a constructor
   the "import" directive                    the "new" operator
   top-down design                           calling a constructor
   bottom-up design                          garbage collection
   using subroutines for program design      object-oriented design
   initialization in a declaration           extending an existing class
      ( For example:  int count = 0; )       subclass
   named constants ("final static")          superclass
   why to use named constants                inheritance
   signature of a subroutine                 polymorphism
   contract of a subroutine                  the special variable "this"
   "public" and "private"                    void
   
   applets                                   Components
   the init() method of an applet            Containers
   paint() and repaint()                     Layouts
   Colors                                    LayoutManagers
   Fonts                                     BorderLayout
   Graphics                                  GridLayout
   events                                    Labels
   event-driven programs                     TextFields
   event listeners                           Canvases
   state machines                            Panels
   mouse events                              Off-screen images
   dragging                                  double-buffering
   Buttons                                   computer animation
   ActionEvents