Java Basics (contd.)

Contents

• Interfaces
• Exceptions and Error Handling

1. Interfaces

Interfaces provide a way to prescribe the behavior that a class must have.  In this sense, an interface bears some resemblance to an abstract class.  An abstract class may contain default implementations for some of its methods; it is an incomplete class that must be specialized by subclassing.   By constrast, an interface does not provide default implementations for any of the methods.  It is just a way of specifying the functions that a class should contain.  There is no notion of specialization through function overriding.

Some points to note about interfaces:

• A class may implement more than one interface, whereas it can only extend one parent class.
• An interface is treated as a reference type.
• Interfaces provide a mechanism for callbacks, rather like pointers to functions in C++.
• An interface can extend another interface.

import java.util.*;

interface Collection {
    final int MAXIMUM = 100;            // An interface can only have constant data.
    public void add(Object obj);
    public void remove();
    public void print();
}

class Stack implements Collection {           // A last in first out (LIFO) process.
    Vector mVector;

    public Stack() {
        mVector = new Vector(0);                // Create an empty vector.
    }

    // This adds an element to the top of the stack.
    public void add(Object obj) {
        if (mVector.size() < MAXIMUM)     // Restrict the size of the Stack.
            mVector.insertElementAt(obj, 0);
        else
            System.out.println("Reached maximum size");
    }

    // This removes an element from the top of the stack.
    public void remove() {
        mVector.removeElementAt(0);
    }

    // This prints out the stack in order from top to bottom.
    public void print() {
        System.out.println("Printing out the stack");
        for (int i = 0; i < mVector.size(); i++)
            System.out.println(mVector.elementAt(i));
    }
}

class Queue implements Collection {           // A first in first out (FIFO) process.
    Vector mVector;

    public Queue() {
        mVector = new Vector(0);                 // Create an empty vector.
    }

    // This adds an element to the bottom of the queue.
    public void add(Object obj) {
        if (mVector.size() < MAXIMUM)      // Restrict the size of the Queue.
            mVector.addElement(obj);
        else
            System.out.println("Reached maximum size");
    }

    // This removes an element from the top of the queue.
    public void remove() {
        mVector.removeElementAt(0);
    }

    // This prints out the queue in order from top to bottom.
    public void print() {
        System.out.println("Printing out the queue");
        for (int i = 0; i < mVector.size(); i++)
            System.out.println(mVector.elementAt(i));
    }
}
 

class Main {
    public static void main(String[] args) {

        // Create a stack and add some objects to it.  The function CreateSomeObjects takes a
        // reference to the Collection interface as an argument, so it does not need to know anything
        // about the Stack class except that it supplies all the methods that the Collection interface
        // requires.  This is an example of using callbacks.
        Stack s = new Stack();
        CreateSomeObjects(s);

        // Remove an element from the stack and then print it out.
        s.remove();
        s.print();         // This will print out the elements 3,7,5.
 

        // Create a queue and add some objects to it.
        Queue q = new Queue();
        CreateSomeObjects(q);

        // Remove an element from the queue and then print it out.
        q.remove();
        q.print();         // This will print out the elements 7,3,4.
    }
 

    // Create some objects and add them to a collection.  Class Integer allows us to create integer
    // objects from the corresponding primitive type, int.
    public static void CreateSomeObjects(Collection c) {
        c.add(new Integer(5));
        c.add(new Integer(7));
        c.add(new Integer(3));
        c.add(new Integer(4));
    }
}
 
 

2. Exceptions and Error Handling

The basic idea behind exceptions is as follows.  Any method with the potential to produce a remediable error should declare the type of error that it can produce using the throws keyword.  The basic remediable error type is class Exception, but one may be more specific about the type of exception that can be thrown e.g. IOException refers to an exception thrown during an input or output operation.  When an exception occurs, we use the throw keyword to actually create the Exception object and exit the function.

Code that has the potential to produce an exception should be placed within the try block of a try-catch statement.  If the code succeeds, then control passes to the next statement following the try-catch statement.  If the code within the try block fails, then the code within the catch block is executed.  The following example illustrates this.
 

class LetterTest {
      char readLetter() throws Exception {        // Indicates type of exception thrown.
             int k;

             k = System.in.read();
             if (k < 'A' || k > 'z') {
                   throw new Exception();                  // Throw an exception.
             }

             return (char)k;
      }

      public static void main(String[] args) {
             LetterTest a = new LetterTest();

             try {
                    char c = a.readLetter();
                    String str;
                    str = "Successfully read letter " + c;
                    System.out.println(str);
              }
             catch (Exception e) {                           // Handle the exception.
                    System.out.println("Failed to read letter.");
             }
      }
}
 

Note: in addition to the Exception class, Java also provides an Error class, which is reserved for those kinds of problems that a reasonable program should not try to catch.