JAVA Exception Handling

Prepared by

Miss. Arati A. Gadgil

2

Errors and Error Handling

An Error is any unexpected result obtained from a program during execution.

Unhandled errors may manifest themselves as incorrect results or behavior, or as abnormal program termination.Errors should be handled by the programmer.

Traditional Error Handling

1.Every method returns a value (flag) indicating either success, failure, or some error condition. The calling method checks the return flag and takes appropriate action.

Downside: programmer must remember to always check the return value and take appropriate action. This requires much code (methods are harder to read) and something may get overlooked.

3

Traditional Error Handling

2. Create a global error handling routine, and use some form of “jump” instruction to call this routine when an error occurs.Downside: “jump” instruction (GoTo) are considered “bad programming practice” and are discouraged. Once you jump to the error routine, you cannot return to the point of origin and so must (probably) exit the program.

Exceptions act similar to method return flags in that any method may raise and exception should it encounter an error.

Exceptions act like global error methods in that the exception mechanism is built into Java; exceptions are handled at many levels in a program, locally and/or globally.

Exception

Due to design errors or coding errors, our programs may fail in unexpected ways during execution.

It is our responsibility to produce quality code that does not fail unexpectedly.

Consequently, we must design error handling into our programs.

An exception is a special type of error object that is created when something goes wrong in a program.

After Java creates the exception object, it sends it to program, this action called throwing an exception. It's up to our program to catch the exception.

5

An exception is a representation of an error condition or a situation that is not the expected result of a method.

Exceptions are built into the Java language and are available to all program code.

Exceptions isolate the code that deals with the error condition from regular program logic.

When an error is detected, an exception is thrown

Any exception which is thrown, must be caught by and exceptionhandler

If the programmer hasn't provided one, the exception will be caught by a catch-all exception handler provided by the system.

6

The default exception handler may terminate the application.

Exceptions can be rethrown if the exception cannot be handled by the block which caught the exception

Java has 5 keywords for exception handling:1.try 2.catch 3.finally 4.throw 5.Throws

7

Exception -Class Hierarchy

Throwable+ Throwable(String message)+ getMessage(): String+ printStackTrace():void

Error Exception

Errors: An error represents a conditionserious enough that most reasonableapplications should not try to catch.- Virtual Machine Error

- out of memory- stack overflow

- Thread Death- Linkage Error

Exceptions: An error which reasonable applications should catch- Array index out of bounds- Arithmetic errors (divide by zero)- Null Pointer Exception- I/O Exceptions

See the Java API Specification for more.

8

Exceptions -Checked and Unchecked

Java allows for two types of exceptions:1.Checked.

If your code invokes a method which is defined to throw checkedexception, your code MUST provide a catch handler

The compiler generates an error if the appropriate catch handler is notPresent

2.UncheckedThese exceptions can occur through normal operation of the virtual machine. You can choose to catch them or not.

If an unchecked exception is not caught, it will go to the default catch-all handler for the application

All Unchecked exceptions are subclassed from RuntimeException

9

Common Java Exceptions.

ArithmeticException :Caused by math errors such as division by zero

ArrayIndexOutOfBoundsException:Caused by bad array indexes

ArrayStoreException: Caused when a program tries to store the wrong type of data in an array

FileNotFoundException: Caused by an attempt to access a nonexistent file

IOException: Caused by general I/O failures, such as inability to read from a file

NullPointerException: Caused by referencing a null objectNumberFormatException: Caused when a conversion between strings and numbers fails

10

OutOfMemoryException: Caused when there's not enough memory to allocate a new object

SecurityException: Caused when an applet tries to perform an action not allowed by the browser'ssecurity setting

StackOverflowException: Caused when the system runs out of stack space

StringIndexOutOfBoundsException:Caused when a program attempts toaccess a nonexistent characterposition in a string

11

Exceptions –Syntaxtry{ // Code which might throw an exception

// ...}catch(FileNotFoundException x){ // code to handle a FileNotFound exception }catch(IOException x){ // code to handle any other I/O exceptions }catch(Exception x){ // Code to catch any other type of exception }finally{ // This code is ALWAYS executed whether an exception was

thrown// or not. A good place to put clean-up code. ie. close// any open files, etc...

}

12

Try-Catch Mechanism

Wherever your code may trigger an exception, the normal code logic is placed inside a block of code starting with the “try” keyword:

After the try block, the code to handle the exception should it arise is placed in a block of code starting with the “catch” keyword.

You may also write an optional “finally” block. This block contains code that is ALWAYS executed, either after the “try” block code, or after the “catch” block code.

Finally blocks can be used for operations that must happen no matter what (i.e. cleanup operations such as closing a file)

13

throws keyword The throws keyword is used in method declaration, in order to explicitlyspecify the exceptions that a particular method might throw. When a method declaration has one or more exceptions defined using throws clause then the method-call must handle all the defined exceptions.

When defining a method you must include a throws clause to declare those exceptions that might be thrown but doesn’t get caught in the method.

If a method is using throws clause along with few exceptions then thisimplicitly tells other methods that – “ If you call me, you must handle these exceptions that I throw”.

Syntax of Throws in java:void MethodName() throws ExceptionName{ Statement1 ... ... }

14

throw Keyword

By default, when an exception condition occurs the system automatically throw an exception to inform user that there is something wrong. However we can also throw exception explicitly based on our own defined condition.

Using “throw keyword” we can throw checked, unchecked and user -defined exceptions.

15

public class ThrowExample {

static void checkEligibilty(int stuage, int stuweight){

if(stuage<12 && stuweight<40) { throw new ArithmeticException("Student is not eligible

for registration"); } else { System.out.println("Entries Valid!!"); }

} public static void main(String args[]){ System.out.println("Welcome to the Registration process!!"); checkEligibilty(10, 39); System.out.println("Have a nice day..");}

}

16

import java.io.*;class Example {

public static void main(String args[]) throws IOException {

FileInputStream fis = null; fis = new FileInputStream("B:/myfile.txt"); int k; while(( k = fis.read() ) != -1) {

System.out.print((char)k);} fis.close();

} }

Declare the exception in the method using throws keyword.

17

import java.io.*; class Example { public static void main(String args[])

{ FileInputStream fis = null; try{

fis = new FileInputStream("B:/myfile.txt"); }catch(FileNotFoundException fnfe) {

System.out.println("The specified file is not exist); }

int k; try{

while(( k = fis.read() ) != -1) { System.out.print((char)k); }

fis.close(); }catch(IOException ioe) { System.out.println("I/O error occurred: "+ioe); } }

}

18

Throw vs Throws in java

1. Throws clause in used to declare an exception and thow keyword is used to throw an exception explicitly.

2. If we see syntax wise than throw is followed by an instance variable and throws is followed by exception class names.

3. The keyword throw is used inside method body to invoke an exception and throws clause is used in method declaration (signature).

4.By using Throw keyword in java you cannot throw more than one exception but using throws you can declare multiple exceptions. PFB the examples.

19

User defined exception

User defined exceptions in java are also known as Custom exceptions. Most of the times when we are developing an application in java, we often feel a need to create and throw our own exceptions. These exceptions are known as User defined or Custom exceptions.

class MyException extends Exception{

String str1; MyException(String str2) {

str1=str2; } public String toString(){

return ("Output String = "+str1) ; }

}

20

class CustomException{

public static void main(String args[]){

try{

throw new MyException("Custom"); // I'm throwing user defined custom exception above } catch(MyException exp){

System.out.println("Hi this is my catch block") ; System.out.println(exp) ;

} }

}

21

Defining Your Own Exceptions

To define your own exception you must do the following:

Create an exception class to hold the exception data.Your exception class must subclass "Exception" or another exception class

To create unchecked exceptions, subclass the RuntimeException class.Minimally, your exception class should provide a constructor which takes the exception description as its argument.

To throw your own exceptions:

If your exception is checked, any method which is going to throw the exception must define it using the throws keyword

When an exceptional condition occurs, create a new instance of theexception and throw it.

22

Rethrowing Exceptions 

M2() throws an exception and M1() handles it and then rethrows it.

class MyException extends Exception { }

public class RethrowException {  

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

catch (Exception e) { System.out.println("main(): Caught " + e.toString()); } }  

public static void M1() throws MyException { try { M2(); }

23

catch (Exception e) {

System.out.println("M1(): Caught e.toString());   System.out.println("M1(): Rethrowing " + e.toString()); throw e; } }  

public static void M2() throws MyException {

System.out.println("M2(): Throwing MyException..."); throw new MyException();

} }

24

Advantages of Exceptions

1: Separating Error-Handling Code from "Regular" Code

2: Propagating Errors Up the Call Stack

3: Grouping and Differentiating Error Types

Thank You

25