Final Exam Review

Tom Kelliher, CS 116

Dec. 12, 2000



Lab 7 due yesterday.

PostLab 7 due tomorrow.

Toolbox due Friday.

Final Friday in Kelley Lecture Hall, 3:00-5:00pm.

Quiz Review


This example pulls together a lot of what we've done this semester.

  1. A stack is a fundamental data structure in CS.

  2. Last in, first out (LIFO) principle: like a stack of trays in a cafeteria line.

  3. Stack parameter: number of items stack can hold.

  4. Stack state: data within the stack (array), top of stack.

  5. Stack operations: empty, full, push, pop.

Integer stack implementation:
import java.applet.*;

public class Driver extends Applet
   Stack s;

   public void init()
      int tempI;
      boolean tempB;

      s = new Stack(10);
      tempB = s.empty();   // Returns true.
      tempB = s.empty();   // Returns false.
      tempI = s.pop();     // Returns 9.
      tempI = s.pop();     // Returns 12.
      tempB = s.empty();   // Returns true.

class Stack
   int topIndex;
   int data[];

   public Stack(int length)
      topIndex = -1;
      data = new int[length];

   boolean empty()
      return topIndex == -1;

   boolean full()
      return topIndex == data.length - 1;

   int pop()
      if (empty())
         // Throw an exception and return.
         return 0;
         return data[topIndex--];

   void push(int newTop)
      if (full())
         // Throw an exception and return.
         data[++topIndex] = newTop;

Control and Calculation

  1. Iterative execution: for, while, and do/while loops.

    When to use?

    Index variable.

  2. Conditional execution: if/else if/else, switch, break.

    Purpose of the break within a switch case.

  3. Conditions --- keys to the above. Precedence, associativity, operators.

    Remember the precedence table.

  4. Arithmetic: Operators and their types. Type conversion: implicit and explicit casts.


  1. Parameter passing: Formal and actual parameters.

  2. Pass by reference vs. pass by value.

  3. Local variables.

  4. Return values and the type of a method.

  5. Special applet methods: init, paint, interface methods for listeners.

  6. Special class methods: The constructor.


  1. Primitive types: int, double, boolean, char, etc.

  2. Arrays: Type, number of elements, declaring, indexing, .length.

  3. Objects: String, Label, TextField, etc.

    Creating your own.

  4. Declaring and instantiating. The actual variable or a reference?

  5. Variable/Object scope. Naming clashes:
    double average(int data[])
       double average;   // dohhh....

Object-Oriented Design

  1. What is the model?

  2. Which object, which action?

  3. extends, inheritance, sub- and super-classes. Overrides.

  4. Public vs. private. Why use?

  5. The use of instance variables

    The use of the constructor.

Event-Driven Programming

  1. Types of events.

  2. Listener classes must implement all interface methods. Interface methods must have code to deal with each event from each object.

  3. Objects must register their events and designate handler objects.

Thomas P. Kelliher
Tue Dec 12 09:19:29 EST 2000
Tom Kelliher