Introduction
In this article we discuss the differences
between exceptions and errors in Java. Both errors and exceptions are derived
from "java.lang.Throwable" in Java.
Difference between exception and error in Java
-
Exceptions are related to
the application and an Error is related to the environment in which the
application is running.
-
An Error can't be recovered as it is fatal in nature, that is
different in the case of an Exception that may not be fatal in all cases.
-
An Exception is basically
divided into two categories, i.e. Checked and Unchecked Exceptions. A
Checked Exception has a special place in the Java programming language and
requires a mandatory try catch finally code block to handle it. On the other
hand an Unchecked Exception is a subclass of Runtime Exception that usually
represents programming errors.
-
Exceptions can be checked or
unchecked to indicate an error caused by the programmer should be handled at
the application level. Whereas errors are always unchecked and usually
indicate a system error or a problem with a low level resource should be
handled at the system level, if possible.
-
Like Exceptions, Errors in
Java are also unchecked. The compiler will not throw a compile time error if
it doesn't see an Error handled with a try catch or finally block. In fact
handling an Error is not a good idea because recovery from an Error is
usually not possible.
1. Error
When a dynamic linking failure or
other hard failure in the Java Virtual Machine occurs, the virtual machine
throws an Error. Simple programs typically do not catch or throw Errors.
A few examples causing Java
Runtime Errors are:
-
Using a negative size in an
array.
-
Conversion of a string into a
number.
-
Divide an integer by zero.
-
Access an element that is out of bounds of an array
-
Store a value that is of
incompatible data type in an array.
-
Cast an instance of base
class to one of its derived classes.
-
Using a null object to
reference an object's member.
-
Capitalization of keywords.
-
Missing brackets in a
no-argument message.
-
Writing the wrong format for
a class method, etcetera.
Example
In this example; we show
different errors.
class MyErrorClass
{
void fun1()
{
int y=102;
// Error, closing brace is missing
void fun2()
{
int x=1220;
}
}
Output
![Fig-1.jpg]()
2. Exception
An exception is called and even occurs during the
execution of a program, that disrupts the normal flow of the program's
instructions.
When an exception occurs within a method, the
method creates an object and hands it off to the runtime system. Creating an
exception object and handing it to the runtime system is called throwing an
exception.
It can occur for any of the following reasons:
- Due to entering invalid data.
- Due to lost of network connection in the
middle of communications.
- Due to missing a required file.
Exception types
Exceptions are divided mainly into the following
three types:
- Checked
- Runtime/unchecked
- Error
Let's take some exception
1. ArithmeticException
If we divide by zero, there occurs an
ArithmeticException.
int x=12230/0;//ArithmeticException
2. NullPointException
If we provide a null value in any variable and
performing some task, that causes an NullPointException.
String str=null;
System.out.println(str.length()); //NullPointException
3. NumberFormatException
The wrong/different formatting of any value, may
cause a NumberFormatException.
String str="xyz";
int x=Integer.parseInt(str); //NumberFormatException
4. ArrayIndexOutOfBoundsException
If we use a value that is an incorrect index then
that causes an ArrayIndexOutOfBoundsException.
int x[]=new int[5];
x[10]=1223; //ArrayIndexOutOfBoundException
Example
In this example; we show an ArithmeticException
and use try-catch to handle this exception.
class ExceptionEx
{
public static void main(String[] args)
{
try
{
int result=1243443/0;
}
catch(ArithmeticException ae)
{
System.out.println(ae);
}
System.out.println("rest code");
}
}
Output
![Fig-2.jpg]()