Scribd
Upload
16 views

Exception Handling in Java

Uploaded by

kumar
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
16 views

Exception Handling in Java

Uploaded by

kumar
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 6

EXCEPTION HANDLING IN JAVA

EXCEPTION:
 Exception means an abnormal condition.
 It is an event that disrupts the normal flow of the program.
 It is an object which is thrown at runtime.

EXCEPTION HANDLING:
 It is a mechanism to handle runtime errors.
 Exception handling done with the exception object.
 Normal flow of the application can be maintained
 It is an object which is thrown at runtime.

TYPES OF ERRORS
There are three types of errors.
1. Syntax errors.
2. Run time error
3. Logic errors
TYPES OF EXCEPTION
There are three types of exception
1. Checked exception
2. Unchecked exception
3. Error
1) Checked Exception
The classes that directly inherit the Throwable class except Runtime Exception and
Error are known as checked exceptions. Checked exceptions are checked at compile-time.
Example: IOException, SQLException

2) Unchecked Exception
The classes that inherit the Runtime Exception are known as unchecked exceptions.
Unchecked exceptions are not checked at compile-time, but they are checked at runtime.
Example: ArithmeticException, NullPointerException,
ArrayIndexOutOfBoundsException

3) Error
Error is irrecoverable.
Example: OutOfMemoryError, VirtualMachineError, AssertionError etc.

EXCEPTION HANDLING KEYWORDS:


1. try
2. catch
3. finally
4. throw
5. throws
I. Try and catch block:

 It should be followed immediately by the catch block.


 single try block can have multiple catch block.
 In multiple catch block "Exception" class should be placed only at the last otherwise
other specified exceptions will be useless.
 Finally block can be used only with the try and catch block.
order of these block should be
 try
 catch
 finally
Catch block
 It is placed directly after the try block to handle one or more exception types.

Syntax of try - catch block


try
{
//statements
}
catch(Exception object)
{
//statements
}

Example:
public class test
{
public static void main(String[] args)
{
try
{
int data=50/0;
}
catch(ArithmeticException e)
{
System.out.println(" Divide by zero exception");
}
System.out.println("Hello");
}
}

output:
Divide by zero exception
hello
ii) Nested try block:
 The try block inside another try block is called as nested try block.
 When a part of a block may cause one error and the entire block itself may cause
another error. In such a cases, exception handler have to be nested.
Syntax:
try
{
statement1;
statement2;
// Inner try block
try
{
statement1;
statement2;
}
catch(Exception ex)
{
//code
}
}
catch(Exception ex)
{
//code
}

Example:
public class test {
public static void main(String args[]) {
try
{
try
{
int data= 10/0;
}
catch(Exception e)
{
System.out.println("ArithmeticException");
}
try
{
int[] arr = new int[6];
arr[7] = 8;
}
catch(Exception e)
{
System.out.println("ArrayIndexOutOfBoundsException");
}
System.out.println("hi");
}
catch(Exception e)
{
System.out.println(e);
}
System.out.println("Hello");
}
}

Output:
ArithmeticException
ArrayIndexOutOfBoundsException
hi
Hello

iii) Finally block


 It is used to execute important code such as closing connection, stream etc.,
 Finally block is always executed whether exception is handled or not.
 Finally block follows try or catch block.
Syntax:
try
{
//Statements
}
catch
{
//Handling exception
}
finally
{
//Statements to be executed
}

Example

public class test


{
public static void main(String[] args)
{
try
{
int data =30/0;
}
catch(Exception e)
{
System.out.println("Arithmetic Exception");
}
finally
{
System.out.println("finally block");
}
System.out.println("Hello Java");
}
}
Output:
Arithmetic Exception
finally block
Hello Java

iv) Throw
 The throw keyword is used to thrown an exception.
 It is used to generate an exception or describe an instance of an exception.
Syntax:
catch(ExceptionType object)
{
throw object;
}
Syntax:
throw new ExceptionType(args);
Example:
public class test
{
public static void main(String[] args)
{
int balance=100,withdraw=1000;
if(balance<withdraw)
{
throw new ArithmeticException("No money");
}
else
{
System.out.println("withdraw");
}}}

Output: Exception in thread "main" java.lang.ArithmeticException: No money

v)Throws
 The throws keyword is used to declare an exception.
 It doesn't throw an exception.
Syntax:
method_name(parameter_list) throws Exception_list
Example:
public class test
{
static void checkAge(int age) throws ArithmeticException
{
if (age < 18)
{
throw new ArithmeticException("Not eligible for voting");
}
else
{
System.out.println("Eligible for voting");
}
}
public static void main(String[] args)
{
checkAge(15);
}
}
Output:
java.lang.ArithmeticException: Not eligible for voting
Advantages of Exception handling:
1. Provision to complete program execution
2. Easy identification of program code and error handling code
3. Propagation of errors
4. Meaningful error reporting
5. Identifying error types

You might also like