Class 13: Exceptions, Continued

Held Thursday, September 16, 1999

Overview

Today, we will conclude our discussion of exceptions and complete a short lab on exceptions. We will then delve into the wonders of Java's arrays which bear some resemblance to Scheme's misnamed vectors.

Notes

• Those of you who wanted more details on Unix file permissions can now find some short notes online
• Rather than doing a lab today, we'll spend a little extra time on exceptions. You'll soon find that you need to use arrays, anyway.
• Are there any final questions on assignment 2?
• Don't forget: you get your first take-home exam tomorrow.
• Mr. Stone will be with us today and tomorrow.
• We may have prospectives visiting tomorrow.
• Tomorrow, we'll probably wrap up our discussion of loops and resume our discussion of the project.
  • Think once again about the components of the project and how they relate to each other.

Contents

• Exceptions, Continued
  • Throwing Exceptions
  • Defining Your Own Types of Exceptions
  • Detour: Java's Primitive Classes
    • Exceptions, Input, and Output
  • Short Lab

Handouts

• Count.java
• About Unix file permissions

Summary

• Exceptions, concluded
  • Throwing and defining your own exceptions
  • Java's ``Primitive'' classes
  • Short lab

Exceptions, Continued

Throwing Exceptions

• At times, you'll want to throw exceptions from a method because your method has encountered problems.
• In these cases, you'll need to
  • Determine which kind of exception to throw (sometimes an existing kind of exception; sometimes a new kind).
  • Define any new types of exceptions you'll need.
  • Determine an appropriate error message.
  • Create and throw the the exception.
  • Indicate that your method throws
• You can build and throw an exception with
  throw new MyException(message);
• For example, suppose you wanted to ensure that the sender of a message was non-empty. You might write:

    public MailMessage(String sender, String recipient, String body)
      throws Exception
    {
      if ((sender == null) || (sender.equals(""))) {
        throw new Exception("Invalid Sender");
      }
      // ...
    } // MailMessage(String, String, String)
  

• Note that this is particularly powerful. Since we send the exception, the mail message is never created!

Defining Your Own Types of Exceptions

• You define your own exception classes with

  public class MyException 
    extends Exception
  {
  } // class MyException
  

• You don't need to include anything in the body due to the wonders of inheritance and polymorphism. This is enough to say that it is possible to create and throw MyException.
• You may also want to create your own parameterized constructor.

  public class MyException
    extends Exception
  {
    public MyException(String msg) {
      super(msg);
    } // MyException(String)
  } // class MyException
  

• This says ``When someone creates a MyException with a String as a parameter, use that string as the parameter to the constructor of Exception (my superclass).''

Detour: Java's Primitive Classes

• At times, you will find a need to use primitive types in places in which Java only permits you to use objects.
• In addition, there are a number of standard functions that you might want to do with the primitive types.
• To support such instances, Java provides object (class) equivalents of the primitive types. These include java.lang.Integer, java.lang.Double, and many many more.
• What good do they do you?
  • You can get the minimum and maximum allowable integer values with Integer.MIN_VALUE and Integer.MAX_VALUE. (The same is true for other types.)
  • You can convert strings to these objects (``parsing'' the value) by passing the string to the class constructor.
  • You can extract the corresonding integer with intValue (and related things).
  • You can convert between bases and also print numbers in different forms. (We'll return to this later in the semester.)
• Unfortunately, some of these methods can throw exceptions, and you must be prepared to handle them.

Exceptions, Input, and Output

• How else do exceptions affect you? It turns out that you need to understand exceptions in order to use many of Java's built-in classes.
• For example, there are many times in which you need to convert a string to a corresponding value (e.g., an integer).
  • You can get access to command-line arguments through the legendary String[] args. The first argument is args[0] and is a string.
• In Java, Integer.parseInt() permits you to to convert integers to strings.

      String whatever;
      // ...
      int i = Integer.parseInt(whatever);
      // ...
  

• Of course, there are alternates (which are somewhat more general). The constructor for the Integer class can build an Integer object from a string. The intValue method extracts the integer value.

      String whatever;
      // ...
      int i = new Integer(whatever).intValue();
      // ...
  

• What should happen when we try to create an integer from something else? It turns out that Java throws an exception.
  • We may then want to (or be required to) catch that exception.

Short Lab

Spend about fifteen minutes on this lab.

• Make a copy of Count.java.

  
  import SimpleOutput;
  
  /**
   * A simple program to illustrate command-line input.
   *
   * @author Samuel A. Rebelsky
   * @version 1.0 of September 1999
   */
  public class Count {
    public static void main(String[] args) {
      // Prepare for output.
      SimpleOutput out = new SimpleOutput();
  
      // Get the maximum number to print.
      int n = Integer.parseInt(args[0]);
      
      for (int i = 0; i <= n; ++i) {
        out.print(i + " ");
      }
      out.println();
    } // main(String[])
  } // class Count
  
  
  

• Read through the code. What could go wrong?
• Compile Count.java.
• Try

  % /home/rebelsky/bin/ji Count 4
  % /home/rebelsky/bin/ji Count 4 5
  % /home/rebelsky/bin/ji Count four
  % /home/rebelsky/bin/ji Count
  

• What happens in each case?
• Update Count.java so that it prints clearer error messages in each case.