1. We create the Button object button with buttonLabel and add it to a Container.
2. We tell the interpreter to listen for button clicks by adding the line button.addActionListener(this);.
3. When the user clicks on the Button an ActionEvent object is created and the method actionPerformed is called.
4. Within actionPerformed we can either use getSource() or getActionCommand() to determine the button click that caused the event to occur.

1. We create the Checkbox object checkbox with checkboxLabel and add it to a Container.
2. We tell the interpreter to listen for checking or unchecking by adding the line checkbox.addItemListener(this);.
3. When the user checks or unchecks checkbox an ItemEvent object is created and the method itemStateChanged is called.
4. Within itemStateChanged, we use the method getStateChange() to determine whether the box was checked or unchecked. We can use the two static integer variables ItemEvent.SELECTED and ItemEvent.DESELECTED to detect whether or the event that triggered the call to itemStateChanged() was a checkbox being checked or unchecked.
5. After we have determined whether or not the event was a checkbox being checked or unchecked we can use getItem() to get the label of the checkbox that was checked or unchecked.

1. public void paint(Graphics g) - normally used to draw graphics on a Panel or Applet
2. public void update(Graphics g) - by default will clear the entire drawing area and then call paint
3. public void repaint() - makes a call to update as soon as the controlling environment (browser/appletviewer) can
4. public void init() - is executed one time when an applet is loaded
5. public void start() - is executed each time an applet becomes visible
6. public void stop() - is executed each time the applet becomes invisible
7. public void destroy() - is executed one time when the controlling environment (browser/appletviewer) is closed

push - place an element on to the stack.


pop - take an element off the top of the stack.


peek - examine the element on the top of the stack without taking it.


empty - determine whether or not the stack is empty.


search - search for the position of a particular element of the stack.

public class Stack extends Vector {
   public Stack();

   public boolean empty();
   public Object peek();
   public Object pop();
   public Object push(Object item);
   public int search(Object o);
}

Vector() - creates an empty vector with initial capacity 10.

Vector(int cap) - creates an empty vector with initial capacity cap.

Vector(int cap,int grow) - creates an empty vector with initial capacity
                           cap and growth factor grow.

• boolean isEmpty() - determines whether or not the Vector is empty
• int size() - returns the number of elements in the Vector
• void addElement(Object) - adds Object to the end of the Vector
• void insertElementAt(Object,int) - adds an element at the given location
• Object firstElement() - returns the first element in the Vector
• void removeAllElements() - empties the Vector
• Object lastElement() - returns the last element in the Vector
• int indexOf(Object) - returns the position of the Object in the Vector
• int indexOf(Object,int) - returns the position of the first location of Object starting at the position int
• Object elementAt(int) - returns the object at position int
• boolean contains(Object) - determines whether or not the Object is in the Vector
• boolean removeElement(Object) - removes Object from the Vector if it is found
• void removeElementAt(int) - removes the Object at position int

class Node {
   private Object datum;
   private Node link;

   public Node(Object item,Node pointer) {
      datum = item;
      link = pointer;
   }
}

public void insert(Object datum) {
   if (head == null) {
      head = new Node(datum,head);
      tail = head;
   } else {
      temporary = new Node(datum,temporary);
      tail.link = temporary;
      tail = temporary;
      temporary = null;
   }
}

1. Set the new node's pointer field to the node which will follow it in the list.
2. Redirect the node which was pointing at that node to point to the new node.

public boolean delete(Object scrap) {
   Node previous = head;

   for (Node current = head;current != null;current = current.link) {
      if (current.datum.equals(scrap) && previous == current) {
         head = current.link;
         if (head == null)
            tail = null;
         nodeCount--;
         return true;
      } else if (current.datum.equals(scrap) && current.link != null)) {
         previous.link = current.link;
         nodeCount--;
         return true;
      } else if (current.datum.equals(scrap) && (current.link == null)) {
         tail = previous;
         previous.link = null;
         nodeCount--;
         return(true);
      }
      previous = current;
      return false;
}

   public void traverse() {
      for (Node start = head;start != null;start = start.link)
         System.out.println(start.datum);
   }

1. It calls itself (directly or indirectly).
2. It has exit criteria by which it does something without making the recursive call.
3. It works with a "smaller" problem or value each time that it is called so that it can make progress towards the exit criteria!

   public int factorial(int num) {
      if (num == 1)
         return(1);
      else 
         return(num*factorial(num-1));
   }

   public int fibonacci(int num) {
      if ((num==0) || (num==1))
         return(1);
      else
         return(fibonacci(num-1) + fibonacci(num-2));
   }

   public int power(int exp) {
      if (exp==1)
         return(number);
      else
         return(number*power(exp-1));
   }

   public void writeBackwards(String s,int index) {
      if (index>=0) {
         System.out.println(s.charAt(index));
         writeBackwards(s,index-1);
      }
   }