Home

      Hosting      Domains       Support       Contacts

Java Tutorial Home 2 3 4 5 6 7 8 9

JAVA Exceptions

- Because Java is robust there are certain runtime errors java does
not like, i.e. arithmetic exceptions, NullPointerException, etc.
InputMismatchException.

Handling Exceptions

  • In a GUI, exceptions will cause a program to terminate.

  • Use exception handlers (try/catch) to prevent program termination because these happen at runtime not compile time. Let the user know what is incorrect and recover with re-prompting or setting defaults.

  •  Use try, catch, and finally blocks. There is also an Exception class that can be used to reuse the classes.

Minimum try/catch Syntax

  • Curly braces are absolutely required.

  • "try" is the code to attempt.

  • "catch” handles the exception, if the exception happens catch redoes the steps necessary.

Checked and Unchecked Exceptions

  • Two kinds of exceptions, checked and unchecked.

  • Anything from a runtime exception is an unchecked exception. Meaning you don't have to provided a try/catch block. Subclasses of Error or RuntimeException.

Exception Class Methods

- getMessage indicates cause of the exception
- toString - indicates cause
- printStackTrace print line number of cod that caused the exception.
- All statements can be put inside the catch block.

 

Catching a NumberFormatException

import javax.swing.JOptionPane;

public class DialogBoxInput
{
  public static void main( String [] args )
  {
    int n = 0;  // declare and initialize variable
 
    // prompt for input
    String s = JOptionPane.showInputDialog( null,
                             "Enter an integer" );
    System.out.println( "You entered " + s );
 
    try
    {
       // attempt to convert the String to an int
       n = Integer.parseInt( s );
       System.out.println( "Conversion was successful." );
    }
    catch ( NumberFormatException nfe )
    {
       System.out.println( "Sorry. incompatible data." );
       System.out.println( "\nOutput from getMessage: \n"
                           + nfe.getMessage( ) );
 
       System.out.println( "\nOutput from toString: \n"
                           + nfe.toString( ) );
       System.out.println( "\nOutput from printStackTrace: " );
       nfe.printStackTrace( );
    }
 
    System.out.println( "\nn is " + n );
  }
}

- If there are no exceptions the catch block does not get executed.
Flow of control goes to the matching catch block with the object type of the exception. parseInt throws the object of NumberFormatException and flow of control moves to this block. You need to initialize 'n' first because the flow of control will go to the catch without assigning anything to 'n'.

Recovering from an Exception

 

import javax.swing.JOptionPane;
 
public class DialogBoxInput
{
  public static void main( String [] args )
  {
    // declare and initialize variables that will be
    // assigned values in the try block
    int n = 0;
    boolean goodInput = false; // flag variable
 
    // priming read
    String s = JOptionPane.showInputDialog( null,
                             "Enter an integer" );
    do
    {
      try
      {
        // attempt to convert the String to an int
        n = Integer.parseInt( s );
        goodInput = true;
      }
      catch ( NumberFormatException nfe )
      {
        s = JOptionPane.showInputDialog( null,
                             s + " is not an integer. "
                             + "Enter an integer" );
      }
    } while ( !goodInput );
 
    JOptionPane.showMessageDialog( null, "The integer is " + n );
  }
}

Catching multiple exceptions

- Any statement that may throw an exception can be in a try block but
you have to put the catch blocks
- You have to remember the hierarchical tree, IndexOutOfBound is a subclass of further classes and you can put in a very general exception, i.e. you can just catch Exception. So start with a specific exception in your catch blocks and then move up the hierarchy for later catches.
- Only one catch block will be executed, and it will be the same object type as the one that was thrown.

try/catch/finally syntax

- finally executes no matter what. If an exception gets thrown, finally executes after the catch. - How often is finally actually used in practice? Finally is good for closing opened resources. This is a very good practice to use.

import javax.swing.JOptionPane;
 
public class Divider
{
  public static void main( String [] args )
  {
    int divisor = 0;
    int quotient = 0;
    int dividend = 100;
    boolean goodInput = false;
 
    String s = JOptionPane.showInputDialog( null,
                             "Enter an integer" );
    do
    {
      try
      {
        // convert the String to an integer
        divisor = Integer.parseInt( s );
        quotient = dividend / divisor;
 
        allOK = true;
      }
      catch ( NumberFormatException nfe )
      {
        s = JOptionPane.showInputDialog( null,
                             s + " not an integer. "
                             + "Enter an integer Please" );
      }
      catch ( ArithmeticException ae )
      {
        s = JOptionPane.showInputDialog( null,
                           "Divisor cannot be 0. "
                           + "Enter an integer Non Zero divisor" );
      }
    } while ( ! allOK);
    JOptionPane.showMessageDialog( null,
                                  "The result is " + quotient );
  }
}


Line divisor = Integer.parseInt( s )may generate a NFE and get the catch on catch ( NumberFormatException nfe ). If the statement generates and AE then compiler hits catch ( ArithmeticException ae ) catch and prompts user again.

User-Defined Exceptions

- EmailAddress class. We already have IllegalArgumentException so extend this class to get an email class.

Extending an Existing Exception.

Throwing an exception

public class IllegalEmailException extends IllegalArgumentException

{
  public IllegalEmailException( String message )
  {
    super( message );
  }
 
Construction invokes IllegalArgumentException
 

public class EmailAddress
{
  public static final char AT_SIGN = '@';
  private String email;
 
  public EmailAddress( String newEmail )
                     throws IllegalEmailException
  {
    if ( newEmail.indexOf( AT_SIGN ) != - 1 )
       email = newEmail;
    else
       throw new IllegalEmailException
             ( "Email address does not contain " + AT_SIGN );
  }
 
  public String getHost( )
  {
    int index = email.indexOf( AT_SIGN );
    return email.substring( index + 1, email.length( ) );
  }
}



Statement throw new IllegalEmailException throws exception of IllegalEmailException using the throw key word. This will be obtained by running a catch for IEE in try/catch block.

If a method throws an exception it must be thrown with the "throw" keyword by creating a new object to throw that the JVM can match.
 

import java.util.Scanner;
 
public class EmailChecker
{
  public static void main( String [] args )
  {
    Scanner scan = new Scanner( System.in );
    System.out.print( "Enter your web hosting email address > " );
    String myEmail = scan.next( );
    try
    {
      EmailAddress address = new EmailAddress( myEmail );
      System.out.println( "Your host is " + address.getHost( ) );
    }
    catch( IllegalEmailException iee )
    {
      System.out.println( iee.getMessage( ) );
    }
  }
}

Sometimes the flow of control is changed by the exception. In general this is bad idea. Also try/catch are costly so if you can error check with if/else you are better off. However, with a database connection, you can't control how many ways this can fail so a try/catch makes sense here. But if you know the failure (ie, checking a substring) then if/else makes sense. A a general rule, if you are using if/else and the code looks like spaghetti it's time to use try/catch. It all depends. If performance is not an issue, use try/catch. But don't use try/catch to control flow.


import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.io.FileNotFoundException;
import java.io.EOFException;
import java.io.IOException;
 
public class ReadingObjects
{
  public static void main( String [] args )
  {
   try
   {
     FileInputStream fis = new FileInputStream( "objects " );
     ObjectInputStream ois = new ObjectInputStream( fis );
 
     try
     {
       while ( true )
       {
         // read object, type cast returned object to FlightRecord
         FlightRecord2 temp = ( FlightRecord2 ) ois.readObject( );
 
         // print the FlightRecord2 object read
         System.out.println( temp );
       }
     } // end inner try block
 
     catch( EOFException eofe )
     {
      System.out.println( "End of the file reached" );
     }
 
     catch( ClassNotFoundException cnfe )
     {
      System.out.println( cnfe.getMessage( ) );
     }
 
     finally
     {
       System.out.println( "Closing file" );
       ois.close( );
     }
   } // end outer try block
 
   catch( FileNotFoundException fnfe )
   {
      System.out.println( "Unable to find objects" );
   }
 
   catch( IOException ioe )
   {
       ioe.printStackTrace( );
   }
 }
}

- The “while” loop runs forever until the endOfFile exception ends the loop.
 

 

Java Tutorial Home 2 3 4 5 6 7 8 9

 


Java Tutorial


| Home | Hosting | Domains | Support |  Contacts |
|
Terms & Condition | Privacy Policy |


 

Copyright © 2005 by HostItWise.com Read our Copyright. All rights reserved.

Garage Door Jo bLeads