| | |
    Java Beginner Home
    Table of Contents
    Introduction to Java
    Getting Started with Java
    Basic Language Elements
    Java Operators
    Java Control Statements
    Java Access Modifiers
    Classes and Objects
    Java Constructors
    Object Serialization
    Java Class Inheritance
    Java Object Type Casting
    Abstract class and Interface
    Java Method Overiding
    Java toString Method
    Java String Class
    Java String Comparison
    Java StringBuffer
    Java Exceptions
    Singleton Pattern
    Java Threads Tutorial
    Java Collections Framework
    Java Date Util
    Swing Tutorial
    Download Java Software
    Advertise
    Feedback
    Java books
    Eclipse Plugin Site

Understanding Java Exceptions



Rules for try, catch and finally Blocks

1. For each try block there can be zero or more catch blocks, but only one finally block. 

2. The catch blocks and finally block must always appear in conjunction with a try block.

3. A try block must be followed by either at least one catch block or one finally block.

4. The order exception handlers in the catch block must be from the most specific exception 

Java exception handling mechanism enables you to catch exceptions in java using try, catch, finally block. be An exception consists of a block of code called a try block, a block of code called a catch block, and the finally block. Let’s examine each of these in detail.

public class DivideException1 {

    public static void main(String[] args) {
    	division(100,0);        // Line 2
        System.out.println("Main Program Terminating");
    }

    public static void division(int totalSum, int totalNumber) {
    	int quotient = -1;
    	System.out.println("Computing Division.");
    	try{
    		quotient  = totalSum/totalNumber;
    		System.out.println("Result is : "+quotient);
    	}
    	catch(Exception e){
    		System.out.println("Exception : "+ e.getMessage());
    	}
    	finally{
    		if(quotient != -1){
    			System.out.println("Finally Block Executes");
    			System.out.println("Result : "+ quotient);
    		}else{
    			System.out.println("Finally Block Executes. Exception Occurred");
    		}

    	}
    }
}

Download DivideException1.javaOutput

Output

Computing Division.
Exception : / by zero
Finally Block Executes. Exception Occurred
Main Program Terminating


As shown above when the divide by zero calculation is attempted, an ArithmeticException is thrown. and program execution is transferred to the catch statement. Because the exception is thrown from the try block, the remaining statements of the try block
are skipped. The finally block executes.

Defining new EXCEPTIONS!!
We can have our own custom Exception handler to deal with special exception conditions instead of using existing exception classes. Custom exceptions usually extend the Exception class directly or any subclass of Exception (making it checked).
The super() call can be used to set a detail message in the throwable. Below is an example that shows the use of Custom exception’s along with how the throw and throws clause are used.

class BadTemperature extends Exception{
	BadTemperature( String reason ){
		super ( reason );
    }
}

class TooHot extends BadTemperature{

	TooHot(){
		super ("Default messaeg : Hot");
    }

	TooHot(String message){
		super (message);
    }
}

class TooCold extends BadTemperature{ 

	TooCold(){
		super ("Default messaeg : Cold");
    }

	TooCold(String message){
		super (message);
    }
}

class TempertureObject{ 

	int temperature;

    TempertureObject( int temp ) {
    	temperature = temp;
    }

    void test() throws TooHot, TooCold {
    	if ( temperature < 70 ) throw new TooCold("Very Cold");
        if ( temperature > 80 ) throw new TooHot("Very Hot");
    }
}

public class ExceptionExample1{   

	private static void temperatureReport( TempertureObject batch ){
		try{   batch.test();
            System.out.println( "Perfect Temperature" );
        }
        catch ( BadTemperature bt ){
        	System.out.println( bt.getMessage( ) );
        }
    }

    public static void main( String[] args ){
    	temperatureReport( new TempertureObject( 100 ) );
        temperatureReport( new TempertureObject( 50 ) );
        temperatureReport( new TempertureObject( 75 ) );
    }
}

Download ExceptionExample.javaOutput

Output

Very Hot
Very Cold
Perfect Temperature

throw, throws statement

A program can explicitly throw an exception using the throw statement besides the implicit exception thrown.

The general format of the throw statement is as follows:

throw <exception reference>;

The Exception reference must be of type Throwable class or one of its subclasses. A detail message can be passed to the constructor when the exception object is created.

throw new TemperatureException(“Too hot”);

A throws clause can be used in the method prototype.

Method() throws <ExceptionType1>,…, <ExceptionTypen> {

}

Each <ExceptionTypei> can be a checked or unchecked or sometimes even a custom Exception. The exception type specified in the throws clause in the method prototype can be a super class type of the actual exceptions thrown. Also an overriding method cannot allow more checked exceptions in its throws clause than the inherited method does.

When an exception is thrown, normal execution is suspended. The runtime system proceeds to find a matching catch block that can handle the exception. Any associated finally block of a try block encountered along the search path is executed. If no handler is found, then the exception is dealt with by the default exception handler at the top level. If a handler is found, execution resumes with the code in its catch block. Below is an example to show the use of a throws and a throw statement.

public class DivideException3 {

    public static void main(String[] args) {
    	try{
    		int result  = division(100,10);
    		result  = division(100,0);
        	System.out.println("result : "+result);
    	}
        catch(ArithmeticException e){
    		System.out.println("Exception : "+ e.getMessage());
    	}
    }

    public static int division(int totalSum, int totalNumber) throws ArithmeticException {
    	int quotient = -1;
    	System.out.println("Computing Division.");
    	try{
    		if(totalNumber == 0){
    			throw new ArithmeticException("Division attempt by 0");
    		}
    		quotient  = totalSum/totalNumber;

    	}
    	finally{
    		if(quotient != -1){
    			System.out.println("Finally Block Executes");
    			System.out.println("Result : "+ quotient);
    		}else{
    			System.out.println("Finally Block Executes. Exception Occurred");
    		}

    	}
    	return quotient;
    }
}

Download DivideException3.javaOutput

Output

Computing Division.
Finally Block Executes
Result : 10
Computing Division.
Finally Block Executes. Exception Occurred
Exception : Division attempt by 0

Using break and return with Exceptions

This example demonstrates the use of the break, continue and return statements with exceptions. Note that the finally block is executed always except when the return statement is executed.

public class ExceptionExample6 {

	public static void main(String[] args) {

		int x = 10, y = 2;
		int counter = 0;
		boolean flag = true;
		while (flag) {
		start:
			try {
				if ( y > 1 )
					break start;
				if ( y < 0 )
					return;
				x = x / y;
				System.out.println ( "x : " + x + " y : "+y );
			}
			catch ( Exception e ) {
				System.out.println ( e.getMessage() );
			}
			finally {
				++counter;
				System.out.println ( "Counter : " + counter );
			}
			--y;
		}
	}
}

Download ExceptionExample6.javaOutput

Output

Counter : 1
x : 10 y : 1
Counter : 2
/ by zero
Counter : 3
Counter : 4

Handling Multiple Exceptions

It should be known by now that we can have multiple catch blocks for a particular try block to handle many different kind of exceptions that can be generated. Below is a program to demonstrate the use of multiple catch blocks.

import java.io.DataInputStream;
import java.io.IOException;

import javax.swing.JOptionPane;
public class ExceptionExample7{
    static int numerator, denominator;

    public ExceptionExample7( int t, int b ){
	numerator = t;
	denominator = b;
    }

    public int divide( ) throws ArithmeticException{
    	return numerator/denominator;
    }

    public static void main( String args[] ){

    	String num, denom;

    	num = JOptionPane.showInputDialog(null, "Enter the Numerator");
    	denom = JOptionPane.showInputDialog(null, "Enter the Denominator");

		try{
		    numerator = Integer.parseInt( num );
		    denominator = Integer.parseInt( denom );
		}
		catch ( NumberFormatException nfe ){
		    System.out.println( "One of the inputs is not an integer" );
		    return;
		}
        catch ( Exception e ){
		    System.out.println( "Exception: " + e.getMessage( ) );
		    return;
        }

		ExceptionExample7 d = new ExceptionExample7( numerator, denominator );
		try{
		    double result = d.divide( );
		    JOptionPane.showMessageDialog(null, "Result : " + result);
		}
		catch ( ArithmeticException ae ){
			System.out.println( "You can't divide by zero" );
		}
		finally{
			System.out.println( "Finally Block is always Executed" );
	    }
    }
}

Download ExceptionExample7.java

«»

Page : 1 2ALL

 
 
    Java is a trademark of Sun Microsystems, Inc.
| | |
© Copyright 2007-08 javabeginner.com