Sponsored Links
Exceptions in Java
The full story of exceptions in the Java language and virtual machine
- Feedback
- Discuss
Page 2 of 5
catch clauses indicate the type of abnormal condition they handle by the type of exception reference they declare. In the example
above, the catch clauses declare exception type TooColdException and TooHotException. Had a single catch clause declared a TemperatureException, a thrown TooColdException or TooHotException still would have been caught, because TemperatureException is the superclass of both these classes. In the object-oriented way of thinking, a TooColdException is a TemperatureException, therefore, a catch clause for TemperatureException also will catch a thrown TooColdException. An example of this is shown below:
// In Source Packet in file except/ex2/VirtualCafe.java
class VirtualCafe {
public static void serveCustomer(VirtualPerson cust,
CoffeeCup cup) {
try {
cust.drinkCoffee(cup);
System.out.println("Coffee is just right.");
}
catch (TemperatureException e) {
// This catches TooColdException, TooHotException,
// as well as TemperatureException.
System.out.println("Coffee is too cold or too hot.");
// Deal with an irate customer...
}
}
}
Multiple catch clauses could handle the same exception because you may, for example, declare two catch clauses, one for TooColdException and another for TemperatureException. In this case, however, you must place the catch clause for TooColdException above the one for TemperatureException, or the source file won't compile. If a catch clause for TemperatureException could be declared before a catch clause for TooColdException, the first catch clause would catch all TooColdExceptions, leaving nothing for the second catch clause to do. The second catch clause would never be reached. The general rule is: subclass catch clauses must precede superclass catch clauses. Here's an example of both orders, only one of which compiles:
// In Source Packet in file except/ex3/VirtualCafe.java
class VirtualCafe {
public static void serveCustomer(VirtualPerson cust,
CoffeeCup cup) {
try {
cust.drinkCoffee(cup);
System.out.println("Coffee is just right.");
}
catch (TemperatureException e) {
// This catches TooColdException, TooHotException,
// as well as TemperatureException.
System.out.println("Coffee is too cold or too hot.");
// Deal with an irate customer...
}
// THIS WON'T COMPILE, BECAUSE THIS catch clause
// WILL NEVER BE REACHED.
catch (TooColdException e) {
System.out.println("Coffee is too cold.");
}
}
}
// In Source Packet in file except/ex4/VirtualCafe.java
// This class compiles fine.
class VirtualCafe {
public static void serveCustomer(VirtualPerson cust,
CoffeeCup cup) {
try {
cust.drinkCoffee(cup);
System.out.println("Coffee is just right.");
}
catch (TooColdException e) {
System.out.println("Coffee is too cold.");
// Deal with an irate customer...
}
catch (TemperatureException e) {
// This catches TooHotException as well
// as TemperatureException.
System.out.println(
"There's temperature trouble in this coffee.");
// Deal with an irate customer...
}
}
}
Embedding information in an exception object
When you throw an exception, you are performing a kind of structured go-to from the place in your program where an abnormal
condition was detected to a place where it can be handled. The Java virtual machine uses the class of the exception object
you throw to decide which catch clause, if any, should be allowed to handle the exception. But an exception doesn't just transfer control from one part of
your program to another, it also transmits information. Because the exception is a full-fledged object that you can define
yourself, you can embed information about the abnormal condition in the object before you throw it. The catch clause can then get the information by querying the exception object directly.
- Feedback
Resources
- Source packet that contains the example code used in this article:
http://www.artima.com/flexiblejava/code.html - An applet that demonstrates how exceptions work inside the JVM:
http://www.artima.com/insidejvm/applets/PlayBall.html - An applet that demonstrates how finally clauses work inside the JVM:
http://www.artima.com/insidejvm/applets/HopAround.html - The Exceptions chapter of the Java Language Specification:
http://java.sun.com/docs/books/jls/second_edition/html/exceptions.doc.html#44044 - An explanation of try-catch-finally blocks from the Java Language Specification:
http://java.sun.com/docs/books/jls/second_edition/html/statements.doc.html#236653 - Exceptions from the perspective of the JVM:
http://java.sun.com/docs/books/vmspec/html/Concepts.doc.html#22727
About Us | Advertise | Contact Us | Terms of Service/Privacy
Copyright, 2006-2008 Network World, Inc. All rights reserved.
If you don't get Exceptions then you are ok! ;DBy Anonymous on November 19, 2009, 5:04 pmIf you don't get Exceptions then you are ok! ;D
Reply | Read entire comment
ExceptionsBy Anonymous on October 23, 2009, 12:13 pmi don't get Exceptions, Help!
Reply | Read entire comment
Why you should use exceptionsBy Anonymous on October 15, 2009, 9:22 amExceptions should be used if something goes wrong with the method. For example: if you make a toInt method and someone passes in a character string, you should...
Reply | Read entire comment
:)By Anonymous on September 25, 2009, 12:12 am:)
Reply | Read entire comment
good tutorialBy Anonymous on September 15, 2009, 11:24 pmthis is a good tutorial about exception. thanks for sharing.
Reply | Read entire comment
View all comments