1. Exception Handling and Format output

2. Midterm exam Date: Oct 31 Content: Week 1 to Week 8 Format:
Multiple choice
Determine the results of the code
Write simple code

3. Introduction
Exception – an indication of a problem that occurs during a program’s execution
Exception handling – resolving exceptions that may occur so program can continue or terminate gracefully
Exception handling enables programmers to create programs that are more robust and fault-tolerant

4. Introduction Examples
ArrayIndexOutOfBoundsException – an attempt is made to access an element past the end of an array
NullPointerException – when a null reference is used where an object is expected

5. Exception-Handling Overview
Intermixing program logic with error-handling logic can make programs difficult to read, modify, maintain and debug
Exception handling enables programmers to remove error-handling code from the “main line” of the program’s execution
Improves clarity
Enhances modifiability

6. Example: Not Catching Exceptions
String inputStr;
int age;
inputStr = JOptionPane.showInputDialog(null, "Age:");
age = Integer.parseInt(inputStr);
Error message for invalid input
Consider the given example. What would happen if the user enters a value such as the text 'ten' instead of 10? The parseInt method cannot convert such an input to an internal numerical format. This type of error is called an exception, and it will result in displaying an error message such as the one shown here. We say the parseInt method has thrown a NumberFormatException.
Exception in thread "main" java.lang.NumberFormatException: For input string: "ten"
at java.lang.NumberFormatException.forInputString(Unknown Source)
at java.lang.Integer.parseInt(Unknown Source)
at Week7.SimpleException.main(SimpleException.java:12)

7. Catching an Exception try catch
inputStr = JOptionPane.showInputDialog(null, "Age:");
try {
age = Integer.parseInt(inputStr);
} catch (NumberFormatException e){
JOptionPane.showMessageDialog(null, "’" + inputStr
+ "‘ is invalid\n"
+ "Please enter digits only"); }
try
catch
This example shows a way to handle a thrown exception in our code, instead of letting the system handle it, as in the previous example. If any statement inside the try block throws an exception, then the statements in the matching catch block are executed. And the program continues the execution from the statement that follows this try-catch statement.

8. Performance Tip
If the potential problems occur infrequently, intermixing program and error-handling logic can degrade a program’s performance, because the program must perform (potentially frequent) tests to determine whether the task executed correctly and the next task can be performed.

9. Try-catch: what does that mean?
When an exception occurs, or is thrown, the normal sequence of flow is terminated. The exception-handling routine is then executed; we say the thrown exception is caught.

10. Try-catch: what does that mean?
try block – encloses code that might throw an exception and the code that should not execute if an exception occurs
Consists of keyword try followed by a block of code enclosed in curly braces

11. Try-catch: what does that mean?
catch block – catches (i.e., receives) and handles an exception, contains:
Begins with keyword catch
Exception parameter in parentheses – exception parameter identifies the exception type and enables catch block to interact with caught exception object
Block of code in curly braces that executes when exception of proper type occurs

12. Try-catch: what does that mean?
Matching catch block – the type of the exception parameter matches the thrown exception type exactly or is a superclass of it
Uncaught exception – an exception that occurs for which there are no matching catch blocks
Cause program to terminate if program has only one thread; Otherwise only current thread is terminated and there may be adverse effects to the rest of the program

13. try-catch Control Flow
This illustrates how the control flows when there is an exception and when there is no exception.
In the case when no statements in the try block throw an exception, then the catch block is skipped and execution continues with the next statement following the try-catch statement.
If any one of the statements throws an exception, the statements in the catch block are executed. Execution then continues to the statement following the try-catch statement, ignoring any remaining statements in the try block.

14. try-catch Control Flow
When an exception occurs:
try block terminates immediately
Program control transfers to first matching catch block
After exception is handled:
Termination model of exception handling – program control does not return to the throw point because the try block has expired; Flow of control proceeds to the first statement after the last catch block
Resumption model of exception handling – program control resumes just after throw point

15. try-catch Control Flow
try statement – consists of try block and corresponding catch and/or finally blocks
Logic errors can occur if you assume that after an exception is handled, control will return to the first statement after the throw point.

16. Tip
With exception handling, a program can continue executing (rather than terminating) after dealing with a problem. This helps ensure the kind of robust applications that contribute to what is called mission-critical computing or business-critical computing.

17. Review To catch an exception, code must be enclosed in a
a. throws block.
b. catch block.
c. try block.
d. finally block.

18. Review To catch an exception, code must be enclosed in a
a. throws block.
b. catch block.
c. try block.
d. finally block.

19. Review An uncaught exception:
a. is a possible exception that never actually occurs during the execution of the program.
b. is an exception that occurs for which the matching catch clause is empty.
c. is an exception that occurs for which there are no matching catch clauses.
d. is another term for a thrown exception

20. Review An uncaught exception:
a. is a possible exception that never actually occurs during the execution of the program.
b. is an exception that occurs for which the matching catch clause is empty.
c. is an exception that occurs for which there are no matching catch clauses.
d. is another term for a thrown exception

21. Getting Information
There are two methods we can call to get information about the thrown exception:
getMessage
printStackTrace
try {
. . .
} catch (NumberFormatException e){
System.out.println(e.getMessage());
e.printStackTrace(); }
In the previous example, we simply displayed a fixed error message. We can get display a more generic error message by using the getMessage or printStrackTrace methods. We will experiment with these methods in the lab.

22. printStackTrace, getStackTrace and getMessage
Methods in class Throwable retrieve more information about an exception
printStackTrace – outputs stack trace to standard error stream
getStackTrace – retrieves stack trace information as an array of StackTraceElement objects; enables custom processing of the exception information
getMessage – returns the descriptive string stored in an exception

23. Multiple catch Blocks
A single try-catch statement can include multiple catch blocks, one for each type of exception.
try {
. . .
age = Integer.parseInt(inputStr);
// Asuming I have a file I/O here
} catch (NumberFormatException e){
} catch (FileNotFoundException file_error){ }
In this example, we see two statements in the try block that can potentially throw exceptions. The parseInt method throws a NumberFormatException while the get method throws an ArrayIndexOutOfBoundsException when the argument id is outside the range of valid values.

24. Multiple catch Control Flow
Here's how the control flows when there are multiple catch blocks.
In the case when no statements in the try block throw an exception, then all catch blocks are skipped and execution continues with the next statement following the try-catch statement.
If any one of the statements throws an exception, the statements in the matching catch block are executed. Execution then continues to the statement following the try-catch statement, ignoring any remaining statements in the try block.

25. The finally Block
There are situations where we need to take certain actions regardless of whether an exception is thrown or not.
We place statements that must be executed regardless of exceptions in the finally block.
The finally block is not used often in introductory level programs, but we will introduce them here for the sake of complete coverage of the topic. For example, suppose we open a communication channel from our Java program to a remote web server to exchange data. If the data exchange is successfully completed in the try block, then we close the communication channel and finish the operation. If the data exchange is interrupted for some reason, an exception is thrown and the operation is aborted. In this case also, we need to close the communication channel, because leaving the channel open by one application blocks other applications from using it. The code to close the communication channel should therefore be placed in the finally block.

26. try-catch-finally Control Flow
Here's how the control flows when there are multiple catch blocks and the finally block.
In the case when no statements in the try block throw an exception, then all catch blocks are skipped, but the statements in the finally block are executed. Execution continues with the next statement following the try-catch statement.
If any one of the statements throws an exception, the statements in the matching catch block are executed first and the statements in the finally block are executed next. Execution then continues to the statement following the try-catch statement, ignoring any remaining statements in the try block.

27. Propagating Exceptions
Instead of catching a thrown exception by using the try-catch statement, we can propagate the thrown exception back to the caller of our method.
The method header includes the reserved word throws.
public int getAge( ) throws NumberFormatException {
. . .
int age = Integer.parseInt(inputStr);
return age; }
Using the try-catch statement is the first way to handle the exceptions. The second way is to propagate the thrown exception back to the caller of the method. The method that includes the statement that calls our method must either catch it or propagate it back to their caller.

28. Throwing Exceptions
We can write a method that throws an exception directly, i.e., this method is the origin of the exception.
Use the throw reserved to create a new instance of the Exception or its subclasses.
The method header includes the reserved word throws.
public void doWork(int num) throws Exception {
. . .
if (num != val) throw new Exception("Invalid val"); }
It is possible to throw an exception from our own method.

29. Sample Call Sequence
This illustration shows a sequence of method calls among the exception throwers.
Method D throws an instance of Exception. The green arrows indicate the direction of calls. The red arrows show the reversing of call sequence, looking for a matching catcher. Method B is the catcher.
The call sequence is traced by using a stack.

30. Exception Thrower
When a method may throw an exception, either directly or indirectly, we call the method an exception thrower.
Every exception thrower must be one of two types:
catcher.
propagator.
We say a method throws an exception directly when the method includes the throw statement. Otherwise, a method is throwing an exception indirectly.

31. Review
Which of the following is not true regarding the throw point of an exception?
a. It specifies the point at which the exception must be handled.
b. It is the initial point at which the exception occurs.
c. It is specified as the top row of the method-call stack at the time the exception occurred.
d. All of the above statements are true.

32. Review
Which of the following is not true regarding the throw point of an exception?
a. It specifies the point at which the exception must be handled.
b. It is the initial point at which the exception occurs.
c. It is specified as the top row of the method-call stack at the time the exception occurred.
d. All of the above statements are true.

33. Review
Which of the following is not true regarding the throw point of an exception?
a. It specifies the point at which the exception must be handled.
b. It is the initial point at which the exception occurs.
c. It is specified as the top row of the method-call stack at the time the exception occurred.
d. All of the above statements are true.

34. Review question Which of the following statements is not true?
a. Exception handling enables programmers to write robust and fault-tolerant programs.
b. Exception handling can only catch the exception but cannot resolve the exception.
c. Exception handling can resolve exceptions.
d. The Java 2 Platform, Standard Edition, Version 1.4 introduced the new chained exception feature.

35. Review question Which of the following statements is not true?
a. Exception handling enables programmers to write robust and fault-tolerant programs.
b. Exception handling can only catch the exception but cannot resolve the exception.
c. Exception handling can resolve exceptions.
d. The Java 2 Platform, Standard Edition, Version 1.4 introduced the new chained exception feature.

36. Debugging 101 execute your Java program line by line
examine the value of variables at different points in the program
How to do:
set a breakpoint in your code so the debugger suspends execution (double-click in the gray margin on the left side of the editor )
choose Run -> Debug As -> Java Applications

37. Types of Exception Throwers
An exception catcher is an exception thrower that includes a matching catch block for the thrown exception.
An exception propagator does not contain a matching catch block.
A method may be a catcher of one exception and a propagator of another.

38. Using the throws Clause
throws clause – specifies the exceptions a method may throws
Appears after method’s parameter list and before the method’s body
Contains a comma-separated list of exceptions
Exceptions can be thrown by statements in method’s body of by methods called in method’s body
Exceptions can be of types listed in throws clause or subclasses

39. When to Use Exception Handling
Exception handling designed to process synchronous errors
Synchronous errors – occur when a statement executes
Asynchronous errors – occur in parallel with and independent of the program’s flow of control

40. Java Exception Hierarchy
All exceptions inherit either directly or indirectly from class Exception
Exception classes form an inheritance hierarchy that can be extended
Class Throwable, superclass of Exception
Only Throwable objects can be used with the exception-handling mechanism
Has two subclasses: Exception and Error
Class Exception and its subclasses represent exception situations that can occur in a Java program and that can be caught by the application
Class Error and its subclasses represent abnormal situations that could happen in the JVM – it is usually not possible for a program to recover from Errors

41. Portion of class Throwable’s inheritance hierarchy.

42. Checked/Compiling vs. Unchecked/Running time
There are two types of exceptions:
Checked/Compiling time
Unchecked/Run time
A checked exception is an exception that is checked at compile time.
All other exceptions are unchecked, or runtime, exceptions. As the name suggests, they are detected only at runtime.

43. Different Handling Rules
When calling a method that can throw checked exceptions
use the try-catch statement and place the call in the try block, or
modify the method header to include the appropriate throws clause.
When calling a method that can throw runtime exceptions, it is optional to use the try-catch statement or modify the method header to include a throws clause.

44. Handling Checked/Compiling Exceptions
Callers of a method that can throw a checked exception must include the try-catch statement in the method body or the throws clause in the header.

45. Handling Unchecked/Runtime Exceptions
It is optional for callers of a method that can throw runtime exceptions to include the try-catch statement in the method body or the throws clause in the header.

46. Java Exception Hierarchy
Two categories of exceptions: checked and unchecked
Checked exceptions
Exceptions that inherit from class Exception but not from RuntimeException
Compiler enforces a catch-or-declare requirement
Compiler checks each method call and method declaration to determine whether the method throws checked exceptions. If so, the compiler ensures that the checked exception is caught or is declared in a throws clause. If not caught or declared, compiler error occurs.

47. Java Exception Hierarchy
Unchecked exceptions
Inherit from class RuntimeException or class Error
Compiler does not check code to see if exception is caught or declared
If an unchecked exception occurs and is not caught, the program terminates or runs with unexpected results
Can typically be prevented by proper coding

48. Java Exception Hierarchy
catch block catches all exceptions of its type and subclasses of its type
If there are multiple catch blocks that match a particular exception type, only the first matching catch block executes
It makes sense to use a catch block of a superclass when all the catch blocks for that class’s subclasses will perform the same functionality

49. Outline

50. Review Exceptions can occur: a. from the Java Virtual Machine.
b. through explicitly mentioned code in a try block.
c. through calls to other methods made in a try block.
d. All of the above.

51. Review Exceptions can occur: a. from the Java Virtual Machine.
b. through explicitly mentioned code in a try block.
c. through calls to other methods made in a try block.
d. All of the above.

52. Review In the catch block below, what is nullPointerException?
catch (NullPointerException nullPointerException ) {
System.err.println(“nullPointerException”);
} // end catch
a. The type of the exception being caught.
b. The name of catch block’s exception parameter.
c. A finally block.
d. An exception handler.

53. Review In the catch block below, what is nullPointerException?
catch (NullPointerException nullPointerException ) {
System.err.println(“nullPointerException”);
} // end catch
a. The type of the exception being caught.
b. The name of catch block’s exception parameter.
c. A finally block.
d. An exception handler.

54. Throwing Exceptions Using the throw Statement
throw statement – used to throw exceptions
Programmers can thrown exceptions themselves from a method if something has gone wrong
throw statement consists of keyword throw followed by the exception object

55. Rethrowing Exceptions
Exceptions are rethrown when a catch block decides either that it cannot process the exception or that it can only partially process it
Exception is deferred to outer try statement
Exception is rethrown by using keyword throw followed by a reference to the exception object

56. Stack Unwinding
Stack unwinding – When an exception is thrown but not caught in a particular scope, the method-call stack is “unwound,” and an attempt is made to catch the exception in the next outer try block.

57. Stack Unwinding When unwinding occurs:
The method in which the exception was not caught terminates
All local variables in that method go out of scope
Control returns to the statement that originally invoked the method – if a try block encloses the method call, an attempt is made to catch the exception.

58. Declaring New Exception Types
You can declare your own exception classes that are specific to the problems that can occur when another program uses your reusable classes
New exception class must extend an existing exception class

59. Declaring New Exception Types
Typically contains only two constructors
One takes no arguments, passes a default exception messages to the superclass constructor
One that receives a customized exception message as a string and passes it to the superclass constructor

60. Preconditions and Postconditions
Preconditions and postconditions are the states before and after a method’s execution
Used to facilitate debugging and improve design
You should state the preconditions and postconditions in a comment before the method declaration

61. Preconditions and Postconditions
Condition that must be true when the method is invoked
Describe method parameters and any other expectations the method has about the current state of a program
If preconditions not met, method’s behavior is undefined

62. Preconditions and Postconditions
Condition that is true after the method successfully returns
Describe the return value and any other side-effects the method may have
When calling a method, you may assume that a method fulfills all of its postconditions

63. Assertions
Assertions are conditions that should be true at a particular point in a method
Help ensure a program’s validity by catching potential bugs
Preconditions and Postconditions are two kinds of assertions
Assertions can be stated as comments or assertions can be validated programmatically using the assert statement

64. assert <boolean expression>;
Assertions
The syntax for the assert statement is
assert <boolean expression>;
where <boolean expression> represents the condition that must be true if the code is working correctly.
If the expression results in false, an AssertionError (a subclass of Error) is thrown.

65. Sample Use #1 public double deposit(double amount) {
double oldBalance = balance;
balance += amount;
assert balance > oldBalance; }
public double withdraw(double amount) {
balance -= amount;
assert balance < oldBalance;

66. Second Form The assert statement may also take the form:
assert <boolean expression>: <expression>;
where <expression> represents the value passed as an argument to the constructor of the AssertionError class. The value serves as the detailed message of a thrown exception.

67. Sample Use #2 public double deposit(double amount) {
double oldBalance = balance;
balance += amount;
assert balance > oldBalance :
"Serious Error – balance did not " +
" increase after deposit"; }

68. Compiling Programs with Assertions
Before Java 2 SDK 1.4, the word assert is a valid nonreserved identifier. In version 1.4 and after, the word assert is treated as a regular identifier to ensure compatibility.
To enable the assertion mechanism, compile the source file using
javac –source 1.4 <source file>