Handling Exceptions

Question 1

Exceptions represent errors that occur while…

Answer 1

…code is executing

Question 2

Java signals an error with…

Answer 2

…an Exception object

Question 3

The Exception object includes…

Answer 3

…a human readable message and a stack track showing the method calls that led to the error.

Question 4

Java signals an error with an Exception. Then…

Answer 4

…the Exception is passed up the call stack until it’s handled.

Question 5

What happens if an Exception is not handled?

Answer 5

The program will stop running. This is why it is important to handle exceptions when possible.

Question 6

Two types of exceptions:

• checked
• unchecked

Answer 6

• a checked exception is verified by the compiler

- an unchecked exception == a run-time exception, is not verified by the compiler

Question 7

Facts about a checked exception:

Answer 7

• a checked exception is verified by the compiler
• a checked exception is declared in code as part of a method’s signature
• a checked exception must be handled, either in the method, or by the code calling the method (enforced by the compiler)

Question 8

What does “handling” an exception mean?

Answer 8

the exception is caught and resolved or acted upon

Question 9

what are some ways to handle an exception?

Answer 9

• print or log an error message
• recovering (means catch and continue, e.g can log then continue?)
• throwing a new type of Exception
• polite message to the user to try again
• automatically retry
• user-friendly error message and fail
• user friendly error message and continue

Question 10

Adding the exception to the method signature is known as propagating the exception

Answer 10

Propagating the exception signals the exception should be passed up the chain to the code that called the method

Question 11

public void write(String str) throws IOException

–when we write code that calls this method…

Answer 11

… we must either handle the exception (try/catch) or propagate it (put in our signature or catch it and throw new exception)

Question 12

Facts about unchecked exceptions:

Answer 12

• the Java compiler cannot predict an unchecked e
• typically a bug and is an unrecoverable error
• subclass of RuntimeException
• may be thrown without being declared or handled
• compiler does require these to be handled at compile time

Question 13

Some examples of unchecked exceptions

Answer 13

• NullPointerException (access an object that hasn’t been created yet)
• calculation amounts to zero in the denominator (ArithmeticException)
• Integer.parse(“not a number”) –> NumberFormatException
• NumberFormatException is a type of IllegalArgumentException (which is a type of Runtime Exception)

Question 14

Some notes about try/catch blocks

Answer 14

• tells the compiler that there may be exceptions thrown within the code inside the try block
• we can choose to 1) put most of a method within the block 2) just the line that may throw an exception 3) create multiple catch blocks for that try 4) create multiple try/catch blocks within the method

It all depends on how we want the code to proceed when an exception occurs

Question 15

a catch block…
catch (Exception e) {
..
}

Answer 15

…defines the type of exception being caught, a variable name for that exception to use within the catch block, and code within the block to execute when such an exception occurs in the preceding try block.
One or more catch blocks can be defined after each try block.

Question 16

An exception is thrown.

The runtime will look for a catch block…

Answer 16

..matching that type of exception being thrown–> this includes any exception type in an exception’s inheritance chain - THE SUBCLASSES of an exception, not any superclass
…the runtime will only execute the first matching catch block by passing in the exception object
…if not matching catchblock is found, the exception is passed up to the caller of the method that is executing (the next method on the call stack)
…Once the catch block executes, the runtime continues after the try and catch blocks (unless the catch block throws a new error?)

Question 17

How to print the exception user readable error message?

catch (Exception e)

Answer 17

System.out.println(e.getMessage());

Question 18

in the following code:
try {
    Order ord=orderDataAccess.get(orderId);
     return fulfullmentService.process(ord)
} catch (SQLException e) {
     System.out.println(.....
}
return false;

why are two lines of code in the try block?

Answer 18

because if the orderDataAccess returns a SQLException, we don’t want the fulfillment to be processed.
If it was after the try/catch block, Java would continue with this line after the error is caught.
We do not want to fulfill an order if we are unable to retrieve one from the OrderDataAccess.
(two lines are coupled functionally)

Question 19

try {
    Order ord=orderDataAccess.get(orderId);
     return fulfullmentService.process(ord)
} catch (SQLException e) {
     System.out.println(.....
} catch (NoFulfillerFoundException e) {
    ....
}
return false;

Answer 19

Here, the exceptions are handled/logged, and the boolean false is sent back to the calling method. The exceptions are not propagated here.

Question 20

is it a good idea to catch the generic Exception at the end of a try/catch block?

Answer 20

No, because we might squash the indication of serious erros that should bubble up, or that should stop the program.
It could hide issues like:
- permission problems
- file system access
- memory problems

Write exceptions to handle specific problems, limit catch blocks to exception types we plan to recover from.

Question 21

Syntax differences between propagating checked and unchecked exceptions

Answer 21

checked exception

1. add the checked exception to my own method’s signature
2. catch the checked exception and throw a different exception - this different exception must be declared in my own method’s signature IF it is a checked exception

uncheckedexception

1. it is automatically propagated
2. catch the unchecked exception and throw a different one - this different exception must be declared in my own method’s signature IF it is a checked exception

Question 22

If an exception is propagated …

Answer 22

…execution in that method is done.

Question 23

If we create a subclass of a class that has methods declaring exceptions...
(same for using an interface)

Answer 23

...we can't make the declarations (of the thrown exception) more generic 
...the subclass cannot throw new checked exceptions
...subclasses may leave off declared exceptions (may avoid situations where checked exceptions occur)

Question 24

If an exception is something we can recover from in my method…

Answer 24

my method should handle it. Leave the program in a state that allows execution to continue.

Question 25

By propagating an exception...

Answer 25

...we are deciding the current method is not the appropriate place to handle the exception, and passing the responsibility of handling the exception further up the calling stack. If no method further up the calling stack handles the exception, the program would crash.

Question 26

At the very least...

Answer 26

we should be logging the exceptions we catch. Don't fail silently.