Chapter 11 ■ Exceptions and Assertions

•Static initialization blocks cannot throw any checked exceptions. Why? Remember that static initialization blocks are invoked when the class is loaded, so there is no way to handle the thrown exceptions in the caller. Further, there is no way to declare the checked exceptions in a throws clause.

•Non-static initialization blocks can throw checked exceptions; however, all the constructors should declare those exceptions in their throws clause. Why? The compiler merges the code for non-static initialization blocks and constructors during its code generation phase, hence the throws clause of the constructor can be used for declaring the checked exceptions that a non-static initialization block can throw.

•An overriding method cannot declare more exceptions in the throws clause than the list of exceptions declared in the throws clause of the base method. Why? The callers of the base method see only the list of the exceptions given in the throws clause of that method and will declare or handle these checked exceptions in their code (and not more than that).

•An overriding method can declare more specific exceptions than the exception(s) listed in the throws clause of the base method; in other words, you can declare derived exceptions in the throws clause of the overriding method.

•If a method is declared in two or more interfaces, and if that method declares to throw different exceptions in the throws clause, the implementation should list all of these exceptions.

Custom Exceptions

In most situations, it will be sufficient to throw exceptions that are already provided in the Java library. For example, if you’re checking for the validity of the arguments passed to a public function, and you find them to be null or out of expected range, you can throw an IllegalArgumentException. However, for most non-trivial applications, it will be necessary for you to develop your own exception classes (custom exceptions) to indicate exceptional conditions.

How do you define a custom exception? There are two options: you can extend either the Exception or RuntimeException class depending on your need. If you want to force the users of your custom exception to handle the exception, then you can extend your exception class from the Exception class, which will make your custom exception a checked exception. If you want to give flexibility to the users of your custom exception, and leave it to the users of your exception to decide if they want to handle the exception or not, you can derive your exception from the RuntimeException class. So it is a design choice that you make to choose the base class of your custom exception. How about extending the Throwable or Error class for custom exceptions? The Throwable class is too generic to make it the base class of your exception, so it is not recommended. The Error class is reserved for fatal exceptions that the JVM can throw (such as StackOverflowError), so it is not advisable to make this the base class of your exception.

Custom exceptions should extend either the Exception or RuntimeException class. It is a bad practice to create custom exceptions by extending the Throwable or Error classes.

For extending from a base class, you need to see what methods the base class provides. In this case, you want to create a custom exception by extending the Exception or RuntimeException classes. Since the Exception class is the base class of the RuntimeException class, it is sufficient to know the members of the Exception class. Table 11-4 lists the important methods (including constructors) of the Exception class.

347

Chapter 11 ■ Exceptions and Assertions

Table 11-4.  Important Methods and Constructors of the Exception Class

For illustrating how to create your own exception classes, assume that you want to create a custom exception named InvalidInputException. When you try to read input (read an integer, in this case), and if it fails, you want to throw this InvalidInputException. Listing 11-23 defines this exception class by extending the RuntimeException class.

Listing 11-23.  InvalidInputException.java

//a custom "unchecked exception" that is meant to be thrown

//when the input provided by the user is invalid

class InvalidInputException extends RuntimeException {

        // default constructor

        public InvalidInputException() {

                super();

        }

        // constructor that takes the String detailed information we pass while // raising an exception

        public InvalidInputException(String str) {

                super(str);

        }

        // constructor that remembers the cause of the exception and // throws the new exception

        public InvalidInputException(Throwable originalException) {

                super(originalException);

        }

348

Chapter 11 ■ exCeptions and assertions

//first argument takes detailed information string created while

//raising an exception

//and the second argument is to remember the cause of the exception public InvalidInputException(String str, Throwable originalException) {

super(str, originalException);

}

}

In this InvalidInputException class, you did not introduce any new fields but you can add any fields if necessary. This is also a simple custom exception where the constructors simply call the base class versions of the same constructor type. The class CustomExceptionTest (see Listing 11-24) shows how to make use of this custom exception.

Listing 11-24. InvalidInputException.java

import java.util.*;

// class for testing the custom exception InvalidInputException class CustomExceptionTest {

public static int readIntFromConsole() {

Scanner consoleScanner = new Scanner(System.in); int typedInt = 0;

try {

typedInt = consoleScanner.nextInt(); } catch(NoSuchElementException nsee) {

System.out.println("Wrapping up the exception and throwing it...");

throw new InvalidInputException("Invalid integer input typed in console", nsee);

}catch(Exception e) {

//call all other exceptions here ...

System.out.println("Error: Encountered an exception and could not read an integer from the console... ");

}

return typedInt;

}

public static void main(String [] args) { System.out.println("Type an integer in the console: "); try {

System.out.println("You typed the integer value: " + readIntFromConsole()); } catch(InvalidInputException iie) {

System.out.println("Error: Invalid input in console... "); System.out.println("The current caught exception is of type: " + iie); System.out.println("The originally caught exception is of type: " + iie.getCause());

}

}

}

349