Data Structures and Algorithms in Java[1].pdf - Fulvio Frisone

}
It is often convenient to instantiate an exception object at the time the exception has
to be thrown. Thus, a throw statement is typically written as follows:
throw new exception_type(param 0 , param 1 , …, param n−1 );
where exception_type is the type of the exception and the param i 's form the list of
parameters for a constructor for this exception.
Exceptions are also thrown by the Java run-time environment itself. For example,
the counterpart to the example above is
ArrayIndexOutOfBoundsException. If we have a six-element array and
ask for the ninth element, then this exception will be thrown by the Java run-time
system.
The Throws Clause
When a method is declared, it is appropriate to specify the exceptions it might
throw. This convention has both a functional and courteous purpose. For one, it
lets users know what to expect. It also lets the Java compiler know which
exceptions to prepare for. The following is an example of such a method
definition:
public void goShopping() throws
ShoppingListTooSmallException,
}
// method body…
OutOfMoneyException {
By specifying all the exceptions that might be thrown by a method, we prepare
others to be able to handle all of the exceptional cases that might arise from using
this method. Another benefit of declaring exceptions is that we do not need to
catch those exceptions in our method. Sometimes this is appropriate in the case
where other code is responsible for causing the circumstances leading up to the
exception.
The following illustrates an exception that is "passed through":
public void getReadyForClass() throws
ShoppingListTooSmallException,
OutOfMoneyException {
112