Exceptions

• Exceptions are for changing the flow of control when some important or unexpected event, usually an error, has occurred.

• They direct processing to part of the program that can try to cope with the error, or at least die gracefully.

• Some examples of errors are: "unable to open a file", "array subscript out of range", "no memory left to allocate", "division by zero", etc.

• Here is a summary of the exception terminology in Java:
  Exception - an error condition that happens at run time.

  Throwing - Causing an exception to occur.

  Catching - Capturing an exception that has just occurred, and executing statements to resolve it in some way.

  Catch Clause - The block that does this.

  Stack Trace - The sequence of call statements that brought control to the method where the exception happened.

• An exception can be set in motion explicitly with the throw statement, or implicitly by carrying out some illegal or invalid action.

• The exception then diverts the normal flow of control (like a goto statement).

• If the programmer has made provision, control will transfer to a section of the program that can recover from the error.

• That section can be in the same method, in the method that called the one where the exception occured, or in the one that called that method, etc. It can continue up the stack of calls that were made at run time.

• If control gets to the top, where your program execution started - and no handler for this exception has yet been found - the program execution will cease, with an explanatory message.

• Exceptions are caused in one of two ways:
  • The program does something illegal (usual cause)

  • The program explicitly generates an exception by executing the throw statement (less usual case)

• The throw statement has this general form:
  throw  ExceptionObject

• The ExceptionObject is an object of a class that extends the class java.lang.Exception.

• Here is an example of a simple program that causes a "division by zero" exception:

    class melon {
       public static void main(String args[]) {
         int i = 1, j = 0, k;
         k = i / j;      // causes division-by-zero error
       }
    }
  

• Compiling and running this program gives the result:

    % javac melon.java
    % java melon
        java.lang.ArithmeticException: / by zero
              at melon.main (melon.java: 5)
  

• There are a certain number of predefined exceptions, like ArithmeticException, known as runtime exceptions.

• When they say runtime they mean it in the sense of "thrown by the runtime library code, not your code".

• This is in contrast with the user-defined exceptions which are generally held to be less severe, and can sometimes be recovered from.

• For example, if a filename could not be opened, prompt the user to enter a new name.

• You don't have to make provision for catching runtime exceptions, you do have to catch other exception types.

• Here is an example of how to create your own exception class (user-defined exception) by extending System.exception:

    class OutofGas extends Exception {}
  
    class banana {
      ...
  
      if (fuel < 0.1) throw new OutofGas();
    }
  

• Any method that throws a user-defined exception must either catch it, or declare it as part of the method interface.

• Execution stops and is transferred to the nearest enclosing try/catch statement.

• Here is the general form of how to catch ("handle") an exception:
  try block

  [catch (arg) block]

  [finally block]

• The try statement says "try these statements, and see if you get an exception".

• The try statement must be followed by at least one (you can have many) catch clause and possibly the finally clause.

• You can only have zero or one finally clause.

• A "block" is a group of statements in curly braces.

• Each catch says "I will handle any exception that matches my argument".

• Matching an argument means that the thrown exception could legally be assigned to the argument exception.

• The finally block, if present is a "last chance to clean up" block.

• The finally block is executed whether an exception occured or not, and whether it was caught or not.

• It is executed irrespective of what happens in the try block and can contain the housekeeping tasks that must always be done when finishing this piece of code.

• Here is an example of the try/catch statement:

    int a[] = new int [5];
    try {
      a[10] = 100;
    }
    catch (ArrayIndexOutOfBoundsException e) {
      System.out.println("Array index is out of bounds");
    }
  

• If none of the catch clauses match the exception that has been thrown (or even if there was a match), the finally clause is executed (if there is one).

• At this point (no handler for this exeception), what happens is the same as if the statement that threw the exception was not rested in a try statement at all. The flow of control abrubtly leaves this method, and a premature return is done to the method that called this one.

• If that call was in the scope of a try statement itself, then we look for a matching exception again, and so on.

• We mentioned that a method must either catch the exceptions that it throws or declare it as a part of its signature, meaning announce the exception to the outside world.

• This is so that anyone who writes a call to that method is alerted to the fact that an exception might come back instead of a normal return.

• This allows the programmer who calls that method to make the choice between handling the exception, or allowing it to progagate further up the stack call.

• Here is the general form of how a method declares the exceptions that might be progagated out of it:

    modifiers_and_returntype name (params) throws e1, e2, e3 {}
  

• The names e1,...etc. must be exception or error names (i.e. any type that is assignable to the predefined type Throwable).

• Note that just as a method signature specifies the return type, it specifies the exception type that can be thrown (rather than an exception object).

• An example, taken from the Java I/O system is:

    char readChar() throws IOException;
  

Arrays

• Arrays are regarded as objects in Java (but arrays are not typical objects, i.e. you can't subclass or extend arrays).

• Most importantly, arrays are a reference type.

• When you declare what looks like an array, you actually get a variable that can hold a reference to an array.

• Here is an example of a simple declaration:

    int carrot[];
  

• Note that you may not specify the array dimension in a declaration like this:

    int carrot[256];  // Wrong!
  

• The array's size is set when you assign something to it, either in an initializer or a regular assignment statement.

• Once an array object has been created with a given size, it cannot change for that array, although you can replace it by assigning a differently-sized array object to it.

• The array can be created like this:

     int carrot[] = new int[256];
  

• This creates a 256 element array, with the default initialization of 0.

• You can also create and initialize arrays in one declaration:

    int    wine[] = {1, 2, 3, 4, 5, 6};
    float  beer[] = {5.5F, p, q, 2.2F};
  

• Array constants (a series of values in braces) can only be used in initializers, not in later assignment statements.

• The length of an array (the number of components in it) is a data field in the array class.

• So you can get the size of an array by referencing:

    a.length;   // the correct way
  

• Make sure you don't confuse this with a method call:

    a.length(); // Wrong!
  

• Suppose you have an array of Strings. Notice the difference between getting the length of the array (the total number of Strings) versus getting the length of a given String in the array:

  public static void main(string args[]) {
   int i = 0;
   System.out.println("number of Strings: " + args.length);
   System.out.println("length of i'th string: " +args[i].length());
  }
  

• Notice how length is a data field for arrays, and is a method for the class String.

• And remember: array subcripts always start at 0, so it means when you declare:

    int day[] = new int[356];
  

• The valid subscripts for day are in the range of 0 to 364.

• It is a common task to copy a range of elements from one array into another.

• You can do this with the arraycopy method:

    System.arraycopy(source, sourceStart, destination, 
                     destStart, length);
  

• The following example doubles the size of the array names:

    String [] temVar = new String[2 * names.length];
    System.arraycopy(names, 0, temVar, 0, names.length);
    names = temvar;
  

Strings

• There are three types that store character sequences available to programmers: String, StringBuffer, and char[].

• The way to decide which to use is to look at the operations available on each and choose the type that most closely matches what you want to do.

String

• Once a string is created, the characters in it cannot be modified, although you can always make a different String using pieces from the String you have.

• So when you use the + operator to concatenate Strings you are actually creating a new String object.

• The String class supports:
  • Literal strings in double quotes

  • Comparisons against the entire string or substring

  • Finding where particular characters occur in the string

  • Constructing a String out of other types including StringBuffer and array of char

• There are many methods that can be used to compare strings.

• The equals method can be used to compare Strings.

• The equals method (which is inherited by class String from its superclass Object) is used to test any two objects for equality (i.e., the contents of the two objects are identical).

• The method returns true if the objects are equal and false otherwise.

• Here is an example:

    s1 = new String( "hello" );
    ...
  
    // test for equality
    if ( s1.equals( "hello" ) )
      System.out.println("s1 equals \"hello\"");
    else
      System.out.println("s1 does not equal \"hello\"");
  

• This result of the preceding call to equals is true and therefore the first statement will be printed.

• A very common mistake is to confuse the equals functionality with the == operator. They are not the same.

• When references are compared with ==, the result is true if both references refer to the same object in memory.

• s1 == "hello" evaluates to false.

• You can use the String method compareTo to compare String objects.

• For example:

    s1 = new String( "hello" );
    s2 = new String( "good bye" );
    ...
  
    s1.compareTo( s2 )
  

• This example compares String s1 to String s2. Method compareTo returns 0 if the Strings are equal, a negative number if the String that invokes compareTo is less than the String that is passed as an argument, and a positive number if the String that invokes compareTo is greater than the String that is passed as an argument.

• Method compareTo uses lexicographical comparison. The value returned is the difference between the integer representations of the first character that is different in each String.

• In the example above, the call to compareTo will return 1 because the integer representation of 'h' is 104 and the integer representation of 'g' is 103.

• There are a whole host of methods for the String class, you are strongly encouraged to read about them (as well as the methods for StringBuffer and char[]).

StringBuffer

• You might use this class if you know you are going to be appending a large number of characters - and you expect to be doing this more than you will do comparisons.

• The StringBuffer class supports:
  • Inserting and appending various types onto a StringBuffer

  • Setting the length of the StringBuffer

Char[]

• This class is an array type so it doesn't have any methods.

• You can only load and store individual array elements.

• However, you do have random access by subcripting to any character in the array, and you can set or change as needed.

• Once created, the number of characters in the array cannot change.

More on Strings

• In contrast to finding the length of an array, getting the length of a String or StringBuffer does require a method call:

    String s = "hello";
    int    i = s.length();
  

• A shortcut to the normal new operator is allowed when giving Strings an initialvalue.

• For example:

    String s = "drinking";
  

• works as well as:

    String s = new String("drinking");