Chapter8 Exceptions&Assertions

8/8/2019 Chapter8 Exceptions&Assertions

1/26

Exception Handling and Assertions


2/26

Objectives

At the end of the lesson, you should be able to:

Explain the basic concepts of exception handling.

Write code to catch and handle exceptions.

Write code to throw exceptions.

Create your own exceptions.

Explain the concepts of assertion.


3/26

What is an Exception?

Exceptional event

Error that occurs during runtime

Cause normal program flow to be disrupted

Examples

Divide by zero errors

Accessing the elements of an array beyond its range

Invalid input

Hard disk crash

Opening a non-existent file

Heap memory exhausted

Exception HandlingWhat is an Exception?

Benefits of Exception Handling

Exception Class Hierarchy

Types of Exception

The Catch or Specify Requirement

Catching Exceptions with try-catch

Catching Exceptions with try-catch-finally

Specifying the Exceptions Thrown by a Method

Throwing Exceptions

Creating Your Own Exception Class


4/26

Exception: An exception is an event, which occurs during the execution of a program thatdisrupts the normal flow of the program's instructions.

When an error occurs within a method, the method creates an object and hands it off to

the runtime system. The object, called an exception object .It containabout the error, including

its type and the state of the program when the error occurred.

Creating an exception object and handing it to the runtime system is called throwing an

exception.

After a method throws an exception, the runtime system attempts to find something to

handle the exception is the ordered list of methods that had been called to get to the method

where the error occurred. The list of methods is known as the call stack.

The runtime system searches the call stack for a method that contains a block of code that

can handle the exception. This block of code is called an exception handler. The exception

handler chosen is said to catch the exception.

Benefits of Exception Handling

Separating Error-Handling code from regular business logic code

Propagating errors up the call stack

Grouping and differentiating error types


5/26

Separating Error-Handling code from regular business logic code -In traditional

programming, error detection,reporting, and handling often lead to confusing code.

Exceptions enable you to write the main flow of your code and to deal with the exceptional cases

elsewhere.

Note that exceptions don't spare you the effort of doing the work of detecting, reporting, and

handling errors, but they do help you organize the work more effectively.

Propagating errors up the call stack-A second advantage of exceptions is the ability to

propagate error reporting up the call stack of methods.

For Example, Suppose that the readFile method is the fourth method in a series of nested method

calls made by the main program: method1 calls method2, which calls method3, which finally

calls readFile. Suppose also that method1 is the only method interested in the errors that might

occur within readFile. Recall that the Java runtime environment searches backward through the

call stack to find any methods that are interested in handling a particular exception. A method

can duck any exceptions thrown within it, thereby allowing a method farther up the call stack to

catch it. Hence, only the methods that care about errors have to worry about detecting errors.

Grouping and differentiating error types-A method can catch an exception based on its group

or general type by specifying any of the exception's superclasses in the catch statement.

Exception Class Hierarchy

The figure below illustrates the class hierarchy of the Throwable class and its

most significant subclasses.


6/26

Throwable class

Root class of exception classes

Subclass of the Object class.

The objects that inherit from the Throwable class include direct descendants (objects

that inherit directly from the Throwable class) and indirect descendants (objects that

inherit from children or grandchildren of the Throwable class).

checked exception :

These are exceptional conditions that a well-written application should anticipate and

recover from.Checked exceptions are subjectto the Catch or Specify Requirement

For example, suppose an application prompts a user for an input file name, then opens the

file by passing the name to the constructor for java.io.FileReader. sometimes the user supplies

the name of a nonexistent file, and the constructor throws java.io.FileNotFoundException. A

well-written program will catch this exception and notify the user of the mistake, possibly

prompting for a corrected file name.

Types of Exception

1. Checked Exception.

It occurs in a java program due to invalid user input, network connectivity problem or

database problems.

2. Unchecked Exception.

It occurs because of programming errors, such as invalid arguments passed to a public

method. The java complier does not check the unchecked exceptions during program compilation.

i. Error

ii. Runtime exception


7/26

Error: Used by the Java run-time system to handle errors occurring in the run-time

environment.Generally beyond the control of user programs

Examples

Out of memory errors Hard disk crash

For example, suppose that an application successfully opens a file for input, but is unable

to read the file because of a hardware or system malfunction. The unsuccessful read will throw

java.io.IOError.

Runtime exception : Conditions that user programs can reasonably deal with. Usually the result

of some flaws in the user program code

Examples

Division by zero error Array out-of-bounds error

For example, consider the application described previously that passes a file name to the

constructor for FileReader. If a logic error causes a null to be passed to the constructor, the

constructor will throw NullPointerException.

The Catch or Specify Requirement

Java code that might throw certain exceptions must be enclosed by either of the following:

o Catching and Handling Exceptions.

Try block

Catch block

Finally block

o Specifying the Exceptions Thrown by a Method.

Code that fails to honor the Catch or Specify Requirement will not compile.
http://java.sun.com/docs/books/tutorial/essential/exceptions/declaring.htmlhttp://java.sun.com/docs/books/tutorial/essential/exceptions/declaring.html


8/26

Try statement that catches the exception. The try must provide a handler for the exception, as

described inCatching and Handling Exceptions.

A method specifies that it can throw the exception. The method must provide a throws clause

that lists the exception, as described in Specifying the Exceptions Thrown by a Method.

Catching Exceptions with try-catchThetry Block:

The first step in constructing an exception handler is to enclose the code that might throw an

exception within a try block.

The catch Blocks:

You associate exception handlers with a try block by providing one or more catch blocks directly

after the try block.

Syntax: Single Exceptiontry {

} catch ( ExceptionType name) {

}

Syntax: Multiple Exceptionstry {

} catch ( ExceptionType1 name)

{

} catch (ExceptionType 2 name)

{

}
http://java.sun.com/docs/books/tutorial/essential/exceptions/handling.htmlhttp://java.sun.com/docs/books/tutorial/essential/exceptions/declaring.htmlhttp://java.sun.com/docs/books/tutorial/essential/exceptions/declaring.htmlhttp://java.sun.com/docs/books/tutorial/essential/exceptions/handling.htmlhttp://java.sun.com/docs/books/tutorial/essential/exceptions/declaring.html


9/26

The segment in the example labeled code contains one or more legal lines of code that could

throw an exception.

The programmer can associate exception handlers with a try block by providing atleast one catch

block or finally block, without this we cant associate exception handler.

Each catch block is an exception handlerand handles the type of exception indicated by its

argument. The argument type, ExceptionType, declares the type of exception that the handler can

handle and must be the name of a class that inherits from the Throwable class. The handler can

refer to the exception with name.

The catch block contains code that is executed if and when the exception handler is invoked. The

runtime system invokes the exception handler when the handler is the first one in the call stack

whoseExceptionType matches the type of the exception thrown. The system considers it a match

if the thrown object can legally be assigned to the exception handler's argument.

Example ForThe try-catch Statements


10/26

class DivByZero {

public static void main(String args[]) { try {

System.out.println(3/0);

System.out.println (Please print me.); } catch (ArithmeticException exc) {

//Division by zero is an ArithmeticException

System.out.println(exc);

}

System.out.println (After exception.);

}

}

Example ForMultiple catch

class MultipleCatch {

public static void main(String args[]) {

try {

int den = Integer.parseInt(args[0]);

System.out.println(3/den);

} catch (ArithmeticException exc) {

System.out.println(Divisor was 0.);

} catch (ArrayIndexOutOfBoundsException exc2) {

System.out.println(Missing argument.);

}

System.out.println(After exception.);}}


11/26

Example ForNested trys

class NestedTryDemo {

public static void main(String args[]){try {

int a = Integer.parseInt(args[0]);

try {

int b = Integer.parseInt(args[1]);System.out.println(a/b);

} catch (ArithmeticException e) {

System.out.println(Div by zero error!");

}

} catch (ArrayIndexOutOfBoundsException) {

System.out.println(Need 2 parameters!");

}}

}

Example ForNested trys with Method

class NestedTryDemo2 {static void nestedTry(String args[]) {

try {

int a = Integer.parseInt(args[0]);

int b = Integer.parseInt(args[1]);System.out.println(a/b);

} catch (ArithmeticException e) {System.out.println("Div by zero error!");

}

}

public static void main(String args[]){

try {

nestedTry(args);

} catch (ArrayIndexOutOfBoundsException e) {

System.out.println("Need 2 parameters!");

}

}

}

Catching Exceptions with try-catch-finally

The finally Block:

The finally blockalways executes when the try block exits. This ensures that the finally block is

executed even if an unexpected exception occurs.

Syntax:try {

} catch ( ExceptionType1 name) {

} catch (ExceptionType 2 name) {

} finally {

}


12/26

If the JVM exits while the try or catch code is being executed, then the finally block will

not execute. Likewise, if the thread executing the try or catch code is interrupted or killed, the

finally block will not execute even though the application as a whole continues.

Note: The finally block is a key tool for preventing resource leaks. When closing a file or

otherwise recovering resources, place the code in a finally block to insure that resource is always

recovered.

Rules for try, catch and finally Blocks :

1. For each try block there can be zero or more catch blocks, but only one finally block.

2. The catch blocks and finally block must always appear in conjunction with a try block.

3. A try block must be followed by either at least one catch block or one finally block.

4. The order exception handlers in the catch block must be from the most specific exception

Example ForThe try-catch -finally Statements

import java.io.*;

public class ListOfNumbers {


13/26

public static void main(String arg[]){

PrintWriter out = null;

try {

System.out.println("Entering try statement");

out = new PrintWriter(

new FileWriter("OutFile.txt"));

out.println("Example for finally blocks");

} catch (IOException e) {

System.err.println("Caught IOException: "+ e.getMessage());

} finally {

if (out != null) {

System.out.println("Closing PrintWriter");

out.close();

} else {

System.out.println("PrintWriter not open");

}

}

}

}

Specifying the Exceptions Thrown by a Method

A method is required to either catch or list all exceptions it might throw

Except for ErrororRuntimeException, or their subclasses

If a method may cause an exception to occur but does not catch it, then it must say so using thethrows keyword

Applies to checked exceptions only

Syntax:

() throws {

}


14/26

The throws statement species the list of exception that has thrown by a method. If a method is

capable of raising an exception that is does not handle, it must specify the exception has to be

handle by the callingmethod, this is done by using the throw statement.

Example for Exceptions Thrown by a Method:

class ThrowingClass {

static void meth() throws ClassNotFoundException{

throw new ClassNotFoundException ("demo");


15/26

}

}

class ThrowsDemo {public static void main(String args[]) {

try {

ThrowingClass.meth();} catch (ClassNotFoundException e) {

System.out.println(e);

}}

}

Output:

java.lang.ClassNotFoundException: demo

Throwing Exceptions

Java allows you to throw exceptions (generate exceptions)

throw ;

We can also create your own exception classes.

To represent problems that can occur within the classes you write.

We can also create chainedexceptions.

An application often responds to an exception by throwing another exception.


16/26

All methods use the throw statement to throw an exception. The throw statement requires

a single argument: a throwable object. Throwable objects are instances of any subclass of the

Throwable class.

Chained Exceptions- In effect, the first exception causes the second exception. It can be very

helpful to know when one exception causes another. Chained Exceptions help the programmer

do this. The following example shows how to use a chained exception.

try {

} catch (IOException e) {throw new SampleException("Other IOException", e);

}

stack trace It provides information on the execution history of the current thread and lists the

names of the classes and methods that were called at the point when the exception occurred. A

stack trace is a useful debugging tool that you'll normally take advantage of when an exception

has been thrown.

Example for Throwing Exceptions :

class ThrowDemo {

public static void main(String args[]){

String input = invalid input;try {


17/26

if (input.equals(invalid input)) {

throw new RuntimeException("throw demo");

} else {System.out.println(input);

}

} catch (RuntimeException e) {System.out.println("Exception caught:" + e);

}

}}

Output:

Exception caught: java.lang.RuntimeException: throw demo

Creating Your Own Exception Class

Steps to follow

Create a class that extends theException class

Customize the class

Members and constructors may be added to the class

Sytntax:

Public class extends Exception {..}


18/26

Java defines several built-in classes for exception handling. All these classes are a part of

the java.lang package which is automatically imported. That is why, while throwing an exception

you did not specifically include any package for exception classes.

Apart from the built-in exception classes you can define your own exception classes. This

is very useful when you want to define exception types which are having a behavior different

from the standard exception type, particularly when you want to do validations in your

application.

You can create muttiple exceptions for different cirumstances in your code, if your code

access different files. You can throw a different exception for each file.This approach is useful

for several reasons:

You can handle each exception differently.

If your exception handlers print out the Exception, this gives you or your users more

information about where the exception occurred.

You can customize your exception.

Example for Creating Your Own Exception Class

class NumberRangeException extends Exception { NumberRangeException () {

super("Enter a number between 20 and 100");


19/26

}

}

public class My_Exception {public static void main (String args [ ]) {

try {

int x = 10;if (x < 20 || x >100) throw new NumberRangeException( );

} catch (NumberRangeException e) {System.out.println (e);

}}

}

Assertion

What are Assertions?

Compiling Files that useAssertions

Enabling and Disabling Assertions

Where You Should Not Use Assertions

Where It Is Good To Use Assertions


20/26

What are Assertions? Statements that let a programmer test assumptions about the state of a program.

Boolean expressions that you believe are true when the assertion executes. If false, system

throws an error.

By verifying expressions, INCREASE confidence that program is error free.

Manual approach: Programmer must insert assertions into a program.

Two forms of the assert statement

Usualform

Syntax: assert ;

Abbreviatedform

Syntax: assert : ;


21/26

An assertion has a Boolean expression that, if evaluated as false, indicates a bug in the

code. This mechanism provides a way to detect when a program starts falling into an inconsistent

state. Assertions are excellent for documenting assumptions and invariants about a class.

In Usualform, if the Booelan Expression evalutates to false, then an AssertionError is

thrown.This error should not be caught,and the program should be terminated abnormally.

In Abbreviatedform, an assert statement has two parts separated by a colon. The boolean

condition must be true for execution to continue. If it is false, an AssertionError is thrown, which

terminates execution and display the message string.

void noReturn() { }

int aReturn() { return 1; }

void go() {int x = 1; boolean b = true;

legal assert statements Illegal assert statementsassert(x == 1);

assert(b);

assert true;

assert(x == 1) : x;

assert(x == 1) : aReturn();

assert(x == 1) : new ValidAssert();

assert(x = 1); // none of these are booleans

assert(x);

assert 0;assert(x == 1) : ; // none of these return a value

assert(x == 1) : noReturn();

assert(x == 1) : ValidAssert va;

Compiling Files that useAssertions

You can use assert as a keyword or as an identifier, but not both.

The Java 5 compiler will use the assert keyword by default.

Command Line If assert Is anIdentifier If assert Is a Keyword

javac -source 1.3

TestAsserts.java

Code compiles withwarnings.

Compilation fails.

javac -source 1.4

TestAsserts.java

Compilation fails. Code compiles.

javac -source 1.5

TestAsserts.java

Compilation fails. Code compiles.

javac -source 5

TestAsserts.java

Compilation fails. Code compiles

javac -source 5

TestAsserts.java

Compilation fails. Code compiles

javac Compilation fails. Code compiles


22/26

If you want to use assertions, you have to think first about how to compile with assertions

in your code, and then about how to run with assertions enabled.

Identifier vs. Keyword

Prior to version 1.4, you might very well have written code like this:

int assert = getInitialValue();

if (assert == getActualResult()) {

// do something

}

Notice that in the preceding code, assert is used as an identifier. That's not a problem prior to 1.4.

But you cannot use a keyword/reserved word as an identifier, and beginning with version 1.4,

assert is a keyword.

If you want to tell the compiler to use Java 5 rules you can do one of three things: omit the

-source option, which is the default, or add one of two source options:

Enabling and Disabling Assertions

Assertions can be turned-on and off.

By default, assertions are turned off

To enable assertions:

java ea classname java ea: classname

or

java enableassertions classname

To disable assertions:

java da classname java da: classname

or

java disableassertions classname

To en/disable system assertions: -esa or -dsa


23/26

Assertions are typically enabled when an application is being tested and debugged, but disabled

when the application is deployed. The assertions are still in the code, although ignored by the

JVM, so if you do have a deployed application that starts misbehaving, you can always choose to

enable assertions in the field for additional testing.

Selective Enabling and Disabling

The command-line switches for assertions can be used in various ways:

With no arguments (as in the preceding examples) Enables or disables assertions in all

classes, except for the system classes.

java ea orjava enableassertions java da orjava -disableassertions

With a package name Enables or disables assertions in the package specified, and any

packages below this package in the same directory hierarchy (more on that in a moment).

java -ea:packagename.subpackage

With a class name Enables or disables assertions in the class specified.

Enable assertions in general, but disable assertions in system classes - java -ea dsaEnable assertions in general,but disable assertions in package - java -ea -da:packagenameWhere You Should Not Use Assertions

Do Use Assertions to Validate Arguments to Public Method and PrivateMethod.

Do not use assertions to do any work that your application requires for

correct operation.


24/26

1. Argument checking is typically part of the published specifications (or contract) of a method,

and these specifications must be obeyed whether assertions are enabled or disabled. Another

problem with using assertions for argument checking is that erroneous arguments should result in

an appropriate runtime exception (such as IllegalArgumentException). An assertion failure will

not throw an appropriate exception.

2. Because assertions may be disabled, programs MUST NOT assume that the boolean

expression contained in an assertion will be evaluated. Violating this rule has dire consequences.

For example, suppose you wanted to remove all of the null elements from a list names, and knew

that the list contained one or more nulls. It would be wrong to do this:

// Broken! - action is contained in assertion

assert names.remove(null);

The program would work fine when asserts were enabled, but would fail when they were

disabled, as it would no longer remove the null elements from the list. The correct idiom is to

perform the action before the assertion and then assert that the action succeeded:

Where It Is Good To Use Assertions

Internal Invariants

You should now use an assertion whenever you would have written a comment that asserts aninvariant.

An assertion is a switch statement with no default case.

Control-Flow Invariants

Place an assertion at any location you assume will not be reached

Preconditions, Postconditions, and Class Invariants

It can help support an informal design-by-contract style of programming.


25/26

Internal Invariants : Example

if (i % 3 == 1) {...

} else {

assert i % 3 == 2 : i;

...}

Control-Flow Invariants : Example

void foo() {

for (...) {

if (...) return;

}

assert false; // Execution should never reach this point!

}

Preconditions, Postconditions, and Class Invariants:

You can test postcondition with assertions in both public and nonpublic methods.

A class invariants is a type of internal invariant that applies to every instance of a class at all

times, except when an instance is in transition from one consistent state to another. A class

invariant can specify the relationships among multiple attributes, and should be true before and

after any method completes.

Switch statement1. default:

2. assert false : suit;


26/26

Chapter8 Exceptions&Assertions

Documents