What is an Exception?
? Exceptional event - typically an 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 Example
1 class DivByZero {
2 public static void main(String args[]) {
3 System.out.println(3/0);
4 System.out.println(“Pls. print me.”);
5 }
6 }
Example: Default Exception Handling
? Displays this error message
Exception in thread "main" java.lang.ArithmeticException: / by zero
at DivByZero.main(DivByZero.java:3)
? Default exception handler
– Provided by Java runtime
– Prints out exception description
– Prints the stack trace
? Hierarchy of methods where the exception occurred
– Causes the program to terminate
Catching Exceptions with try-catch
Catching Exceptions:
The try-catch Statements
? Syntax:
try {
<code to be monitored for exceptions>
} catch (<ExceptionType1> <ObjName>) {
<handler if ExceptionType1 occurs>
}
...
} catch (<ExceptionTypeN> <ObjName>) {
<handler if ExceptionTypeN occurs>
}
The try-catch Statements
1 class DivByZero {
2 public static void main(String args[]) {
3 try {
4 System.out.println(3/0);
5 System.out.println(“Please print me.”);
6 } catch (ArithmeticException exc) {
7 //Division by zero is an ArithmeticException
8 System.out.println(exc);
9 }
10 System.out.println(“After exception.”);
11 }
12 }
Catching Exceptions: Nested try's
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!");
}
}
}
Catching Exceptions with finally
Catching Exceptions:
The finally Keyword
? Syntax:
try {
<code to be monitored for exceptions>
} catch (<ExceptionType1> <ObjName>) {
<handler if ExceptionType1 occurs>
} ...
} finally {
<code to be executed before the try block ends>
}
? Contains the code for cleaning up after a try or a
catch
? Block of code is always executed despite of different scenarios:
– Forced exit occurs using a return, a continue or a break statement
– Normal completion
– Caught exception thrown
? Exception was thrown and caught in the method
– Uncaught exception thrown
? Exception thrown was not specified in any catch block in the method
Throwing Exceptions
Throwing Exceptions: The throw Keyword
? Java allows you to throw exceptions (generate exceptions)
throw <exception object>;
? An exception you throw is an object
– You have to create an exception object in the same way you create any other object
? Example:
throw new ArithmeticException(“testing...”);
Example: Throwing Exceptions
1 class ThrowDemo {
2 public static void main(String args[]){
3 String input = “invalid input”;
4 try {
5 if (input.equals(“invalid input”)) {
6 throw new RuntimeException("throw demo");
7 } else {
8 System.out.println(input);
9 }
10 System.out.println("After throwing");
11 } catch (RuntimeException e) {
12 System.out.println("Exception caught:" + e);
13 }
14 }
15 }
Rules in Exception Handling
? A method is required to either catch or list all exceptions it might throw
– Except for Error or RuntimeException, or their subclasses
? If a method may cause an exception to occur but does not catch it, then it must say so using the throws keyword
– Applies to checked exceptions only
? Syntax:
<type> <methodName> (<parameterList>)
throws <exceptionList> {
<methodBody>
}
Example: Method throwing an Exception
1 class ThrowingClass {
2 static void meth() throws ClassNotFoundException {
3 throw new ClassNotFoundException ("demo");
4 }
5 }
6 class ThrowsDemo {
7 public static void main(String args[]) {
8 try {
9 ThrowingClass.meth();
10 } catch (ClassNotFoundException e) {
11 System.out.println(e);
12 }
13 }
14 }
Exception Class Hierarchy
The Error and Exception Classes
? Throwable class
– Root class of exception classes
– Immediate subclasses
? Error
? Exception
? Exception class
– 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
? Error class
– 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
Exception Classes and Hierarchy
? Multiple catches should be ordered from subclass to superclass.
1 class MultipleCatchError {
2 public static void main(String args[]){
3 try {
4 int a = Integer.parseInt(args [0]);
5 int b = Integer.parseInt(args [1]);
6 System.out.println(a/b);
– } catch (ArrayIndexOutOfBoundsException e) {
– } catch (Exception ex) {
1 }
2 }
3 }
Checked Exceptions & Unchecked Exceptions
? Checked exception
– Java compiler checks if the program either catches or lists the occurring checked exception
– If not, compiler error will occur
? Unchecked exceptions
– Not subject to compile-time checking for exception handling
– Built-in unchecked exception classes
? Error
? RuntimeException
? Their subclasses
– Handling all these exceptions may make the program cluttered and may become a nuisance
Creating Your Own Exception Class
? Steps to follow
– Create a class that extends the RuntimeException or the Exception class
– Customize the class
? Members and constructors may be added to the class
? Example:
1 class HateStringExp extends RuntimeException {
2 /* some code */
3 }
How To Use Your Own Exceptions
1 class TestHateString {
2 public static void main(String args[]) {
3 String input = "invalid input";
4 try {
5 if (input.equals("invalid input")) {
6 throw new HateStringExp();
7 }
8 System.out.println("Accept string.");
9 } catch (HateStringExp e) {
10 System.out.println("Hate string!”);
11 }
12 }
13 }
Assertions
What are Assertions?
? Allow the programmer to find out if the program behaves as expected
? Informs the person reading the code that a particular condition should always be satisfied
– Running the program informs you if assertions made are true or not
– If an assertion is not true, an AssertionError is thrown
? User has the option to turn it off or on when running the application
Enabling or Disabling Assertions
? Program with assertions may not work properly if used by clients not aware that assertions were used in the code
? Compiling
– With assertion feature:
javac –source 1.4 MyProgram.java
– Without the assertion feature:
javac MyProgram.java
? Enabling assertions:
– Use the –enableassertions or –ea switch.
java –enableassertions MyProgram
Assert Syntax
? Two forms:
– Simpler form:
assert <expression1>;
where
? <expression1> is the condition asserted to be true
– Other form:
assert <expression1> : <expression2>;
where
? <expression1> is the condition asserted to be true
? <expression2> is some information helpful in diagnosing why the statement failed
Assert Syntax
1 class AgeAssert {
2 public static void main(String args[]) {
3 int age = Integer.parseInt(args[0]);
4 assert(age>0);
5 /* if age is valid (i.e., age>0) */
6 if (age >= 18) {
7 System.out.println(“You're an adult! =)”);
8 }
9 }
10 }
