| exception - an object representing details of a program failure. An exception is thrown to indicate a failure has occured. |
Java uses exceptions to signal failure, such as division by 0, as in the example below.
public class Div
{public int divide()
{return 123 / 0;
}}
The problem is our program just died! Not an impressive performance but errors do occur.
A more robust approach than dying is to catch exceptions and try to recover gracefully.
Below, we:
- try division
- dividing by zero throws an exception
- catch the exception
|
Example |
Terminal Output |
public class Example
{
public int divide()
{
try
{
return 123 / 0;
}
catch(Exception e)
{
System.out.println("Error!! " + e);
}
return 0;
}
}
|
Error!! java.lang.ArithmeticException: / by zero |
The basic exception mechanism consists of four elements:
- throws Exception in the signature states that a method may
throw an exception, or not, depending on the circumstances. Division
normally does not except when dividing by 0.
- throw new Exception("I am an exception") constructs an
Exception with the string "I am an exception" and throws it to the
caller.
- try { } defines the statements that may throw an exception.
The call to method test() must be in a try {} block
because of the throws Exception in the signature.
- catch( Exception e ) is called by throw new Exception("I am an exception") with e="I am an exception".
|
Example |
Terminal Output |
public class Example
{
public void start()
{
System.out.println("1");
try
{
System.out.println("2");
test();
System.out.println("3");
}
catch(Exception e)
{
System.out.println("4 "+ e);
}
System.out.println("5");
}
private void test() throws Exception
{
throw new Exception("I am an exception");
}
}
|
1 2 4 java.lang.Exception: I am an exception 5 |
In the following example, an exception is thrown on attempting division by zero.
|
Example |
Terminal Output |
public class Example
{
public void start()
{
System.out.println("1");
try
{
System.out.println("2");
System.out.println("3 "+ divide(9, 0) );
}
catch(Exception e)
{
System.out.println("4 "+ e);
}
System.out.println("5");
}
public int divide( int dividend, int divisor) throws Exception
{
if( divisor == 0) throw new Exception("Dividing by zero");
return dividend / divisor;
}
}
|
1 2 4 java.lang.Exception: Dividing by zero 5 |
We have used special return values to indicate failure.
In the Zuul game, false is returned when no door from the Room exists in the direction.
There are several problems with this approach:
- false can represent a failure or success in the Game.
- No magic value is used by everyone to indicate failure,
making it harder to recognize failure indicators in a program.
- The failure can be ignored; goRoom() cannot be forced into action on failure.
|
Game |
Player |
| private void goRoom(Command command) { String direction = command.getSecondWord(); if ( !player.go(direction) ) // No door System.out.println("There is no door!"); else // Door System.out.println(player.roomDescription()); } |
public boolean go(String direction) { Room nextRoom = currentRoom.getExit(direction); if (nextRoom == null) // No door return false; else { // Door currentRoom = nextRoom; return true; } } |
A better approach is to use exceptions, a formal means of indicating failure with the advantages:
- Impossible to ignore,
- Part of the language, purpose recognized by everyone.
|
Game |
Player |
| private void goRoom(Command command) { String direction = command.getSecondWord(); try { player.go(direction); System.out.println(player.roomDescription()); } catch(Exception ex) { System.out.println("Exception " + ex); } } |
public void go(String direction) throws Exception { Room nextRoom = currentRoom.getExit(direction); if (nextRoom == null) throw new Exception("No door"); else currentRoom = nextRoom; } |
