exception handling in java - wordpress.com€¦ · syntax errors - compilation errors. ... catch:...
TRANSCRIPT
Exception Handling in JavaAn Object oriented Way for Handling Errors
An Exception is an event, which occurs during theexecution of a program, that disrupts the normal flowof the program's Instructions.
This is one of the powerful feature of Java to handlerun time error and maintain normal flow of javaapplication.
It is common to make mistakes while developing as well as typing a program.
Such mistakes are categorised as:
syntax errors - compilation errors.
semantic errors– leads to programs producing unexpected outputs.
runtime errors – most often lead to abnormal termination of programs or even cause the system to crash.
Dividing a number by zero.
Accessing an element that is out of bounds of an array.
Trying to store incompatible data elements.
Using negative value as array size.
Trying to convert from string data to a specific data value (e.g., converting string “abc” to integer value).
File errors: opening a file in “read mode” that does not exist or
no read permission
Opening a file in “write/update mode” which has “read only” permission.
Corrupting memory: - common with pointers
3
LinkageError
Error
Throwable
ClassNotFoundException
VirtualMachineError
IOException
Exception
RuntimeException
Object
ArithmeticException
NullPointerException
IndexOutOfBoundsException
Many more classes
Many more classes
Many more classes
IllegalArgumentException
System errors are thrown by
JVM and represented in the
Error class. The Error class
describes internal system
errors. Such errors rarely
occur.
Exception describes
errors caused by your
program and external
circumstances. These
errors can be caught
and handled by your
program.
Handling Exception means transferring execution ofprogram to appropriate handler when an exception occurs.We can handle exception by using try catch block.
try: try is used to define block of code where exceptioncan occur.
catch: catch is used to match specific type of exception.There could be more than one catch clause for one tryblock.
finally: finally determine block of code which will alwaysexecute after try block. Even in case of Exception.
throw: throw keyword is used to throw an exceptionexplicitly.
throws: is a keyword in java language which is used tothrow the exception which is raised in the called methodto it's calling method throws keyword always followed bymethod signature.
try Block
Statements that causes
an exception
catch Block
Statements that
handle the exception
Throws
exception
Object
7
Exception
"thrown" here
Exception
handler
Exception
handler
Thrown exception matched against
first set of exception handlers
If it fails to match, it is matched
against next set of handlers, etc.
If exception matches none of
handlers, program is abandoned
8
Preceding step
try block
throw
statement
unmatched catch
matching catch
unmatched catch
next step
ArithmeticException
ArrayIndexOutOfBoundException
ArrayStoreException
FileNotFoundException
IOException – general I/O failure
NullPointerException – referencing a null object
OutOfMemoryException
SecurityException – when applet tries to perform an action not allowed by the browser’s security setting.
StackOverflowException
StringIndexOutOfBoundException
9
without Exception Handling Exception Handling
class ExceptionDemo {
public static void main(String[] args)
{
int a=10,
ans=0;
ans=a/0; System.out.println("Denominator not be zero");
}
}
class ExceptionDemo {
public static void main(String[] args) {
int a=10, ans=0;
try
{
ans=a/0;
}
catch (Exception e)
{
System.out.println("Denominator not be
zero");
} } }
Abnormally terminate program and give a
message like below, this error message is
not understandable by user so we convert
this error message into user friendly error
message, like "denominator not be zero".
Output:
Output:
Denominator not be zero
Program does not reach here
Program reaches here
When the JVM encounters an error such asdivide by zero, it creates an exceptionobject and throws it – as a notificationthat an error has occurred.
If the exception object is not caught andhandled properly, the interpreter willdisplay an error and terminate theprogram.
If we want the program to continue withexecution of the remaining code, then weshould try to catch the exception objectthrown by the error condition and thentake appropriate corrective actions. Thistask is known as exception handling.
try and catch block
try block Inside try block we write the block of statements which
causes executions at run time in other words try blockalways contains problematic statements.
Each and every try block must contains at least one catchblock. But it is highly recommended to write multiple catchblocks for generating multiple user friendly error messages.
One try block can contains another try block that is nestedor inner try block can be possible.
catch block Inside catch block we write the block of statements
which will generates user friendly error messages.
Catch block will execute exception occurs in tryblock.
You can write multiple catch blocks
At a time only one catch block will execute out ofmultiple catch blocks.
Checked Exception are the exception which checkedat compile-time. These exception are directly sub-class of java.lang.Exception class. Checked exceptionare checked by the compiler at compile-time.
e.g. FileNotFoundException, NumberNotFoundExceptionetc.
Un-Checked Exception are the exception bothidentifies or raised at run time. These exception aredirectly sub-class of java.lang.RuntimeExceptionclass. In real time application mostly we can handleun-checked exception. Un-checked means notchecked by compiler and are checked at run-time notcompile time.
e.g.ArithmeticException, NullPointerException, ArrayIndexOutOfBoundsException etc.
Checked Exception Classes Un-Checked Exception Classes
FileNotFoundException
ClassNotFoundException
IOException
InterruptedException
ArithmeticException
ArrayIndexOutOfBoundsException
StringIndexOutOfBoundsException
NumberFormateException
NullPointerException
NoSuchMethodException
NoSuchFieldException
Exception Example
ArithmeticException
ArrayIndexOutOfBoundsException
StringIndexOutOfBoundsException
NumberFormatException
NullPointerException
NoSuchMethodException This exception will be raised whenever
calling method is not existing in the
program.
FileNotFoundException In case the file is missing, the following
output is produced:
Divide by
zero
exception
Programs can throw an exception explicitly.
throw ThrowableInstance;
The exception must be of type
java.lang.Throwable class or it’s sub classes.
Primitive types, such as int or char, as well as
non-Throwable classes, such as String and
Object, cannot be used as exceptions.
There are two ways you can obtain a
Throwable object: using a parameter in a
catch clause, or creating one with the new
operator
The flow of execution stops immediately
after the throw statement; any subsequent
statements are not executed.
The nearest enclosing try block is inspected
to see if it has a catch statement that
matches the type of exception.
If no matching catch is found, then the
default exception handler halts the program
and prints the stack trace.
How to throw an already defined exception using throw keyword
class AgeValidator
{
static void validateStudent(int age){
try {
if(age<5)
throw new ArithmeticException("age to play more");
else
System.out.println("welcome to school");
}
catch (ArithmeticException e)
{
System.out.println(e);
}
}
public static void main(String args[])
{
validateStudent(4);
}}
class ThrowDemo {
static void demoproc() {
try {
throw new NullPointerException("demo");
} catch(NullPointerException e) {
System.out.println("Caught inside demoproc.");
}
}
public static void main(String args[])
{
demoproc();
}
}
class Exception2{
static int sum(int num1, int num2){
try
{
if (num1 == 0)
throw new ArithmeticException("First parameter is not valid");
else
System.out.println("Both parameters are correct!!");
}
catch (ArithmeticException e)
{
System.out.println(e);
}
return num1+num2;
}
public static void main(String args[]){
int res=sum(3,12);
System.out.println(res);
System.out.println("Continue Next statements");
}
}
If a method is capable of causing an exceptionthat it does not handle, it must specify thisbehavior so that callers of the method can guardthemselves against that exception.
A throws clause lists the types of exceptions thata method might throw.
This is necessary for all exceptions, except thoseof type Error or RuntimeException, or any of theirsubclasses.
type method(args-list) throws exception-list
{
// body of method
}
exception-list is a comma-separated list of theexceptions that a method can throw.
class ThrowsDemo {
static void throwOne() throws IllegalAccessException
{
System.out.println("Inside throwOne.");
throw new IllegalAccessException("demo");
}
public static void main(String args[]) {
try {
throwOne();
}
catch (IllegalAccessException e) {
System.out.println("Caught " + e);
}
}}
O/P:
Inside throwOne
Caught java.lang.IllegalAccessException: demo
class ThrowExample1 {
void mymethod(int num) throws ArithmeticException, ClassNotFoundException{
if(num==1)
throw new ArithmeticException("Number is one");
else
throw new ClassNotFoundException("Number is not one");
}
}
class ThrowExample{
public static void main(String args[]){
try{
ThrowExample1 obj=new ThrowExample1();
//obj.mymethod(2);
obj.mymethod(1);
}
catch(Exception ex)
{
System.out.println(ex);
}
}
}
Built-in exception classes handle somegeneric errors.
For application-specific errors define yourown exception classes.
Define a subclass of Exception:
class MyException extends Exception { … }
MyException need not implement anything –its mere existence in the type system allowsto use its objects as exceptions.
If any exception is design by the user knownas user defined or Custom Exception
User defined exception-Example
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
Note: 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 the exception and throw it.
finally block Java finally block is a block that is used to execute
important code such as closing connection, stream etc.
Java finally block is always executed whether exception is
handled or not.
Java finally block must be followed by try or catch block.
Writing finally block is optional.
Write a program for finding a Sum of Valid Integer Values
Passed as Command Line Parameters by leaving Invalid
data from the Command Line.
(Hint: use NumberFormatException).
Create a custom exception class named LowGpaException
extended from the class Exception. This class should
contain a constructor with no parameter to call the
Exception class constructor with the message “Your GPA is
not sufficient to apply for this job (2.5)”.
Write a program to implement the following
ArithmeticException
StringIndexOutOfBoundsException
ArrayIndexOutOfBoundsException