- Exception subclasses
represent errors that a program can reasonably recover from. Except for RuntimeException and its subclasses (see
below), they generally represent errors that a program will expect
to occur in the normal course of duty: for example, network connection
errors and filing system errors.
- Error subclasses
represent "serious" errors that a program generally shouldn't
expect to catch and recover from. These include conditions such as an
expected class file being missing, or an OutOfMemoryError.
- RuntimeException is a
further subclass of Exception. RuntimeException and its subclasses
are slightly different: they represent exceptions that a program shouldn't
generally expect to occur, but could potentially recover from. They
represent what are likely to be programming errors rather
than errors due to invalid user input or a badly configured environment.
Unchecked
exceptions:
· ·
Represent defects in the program (bugs) - often invalid arguments
passed to a non-private method. "Unchecked runtime exceptions represent
conditions that, generally speaking, reflect errors in your program's logic and
cannot be reasonably recovered from at run time."
· They DON'T have to be caught or declared thrown.
· They are subclasses of java.lang.RuntimeException, and are
usually implemented using IllegalArgumentException, NullPointerException, or
IllegalStateException
·
A method is not obliged to establish a policy for the unchecked
exceptions thrown by its implementation (and they almost always do not do so)
Checked exceptions:
·
Represent invalid conditions in areas outside the immediate
control of the program (invalid user input, database problems, network outages,
absent files)
·
Checked exceptions must be explicitly caught or propagated as
described in Basic try-catch-finally Exception Handling.
·
They are subclasses of java.lang.Exception
·
A method is obliged to establish a policy for all checked
exceptions thrown by its implementation (either pass the checked exception
further up the stack, or handle it somehow)
·
It is somewhat confusing, but note as well that RuntimeException
(unchecked) is itself a subclass of Exception (checked).
List of Checked Exceptions-
Following are the list of various checked exception that defined
in the java. lang package.
Exception
|
Reason
for Exception
|
ClassNotFoundException
|
This
Exception occurs when Java run-time system fail to find the specified class
mentioned in the program
|
Instantiation
Exception
|
This
Exception occurs when you create an object of an abstract class and interface
|
Illegal
Access Exception
|
This
Exception occurs when you create an object of an abstract class and interface
|
Not
Such Method Exception
|
This
Exception occurs when the method you call does not exist in class
|
2. Unchecked Exception:- These Exception arises during run-time
,that occur due to invalid argument passed to method. The java Compiler
does not check the program error during compilation. For Example when you
divide a number by zero, run-time exception is raised.
Exception
|
Reason for Exception
|
Arithmetic
Exception
|
These
Exception occurs, when you divide a number by zero causes an Arithmetic
Exception
|
Class
Cast Exception
|
These
Exception occurs, when you try to assign a reference variable of a class to
an incompatible reference variable of another class
|
Array
Store Exception
|
These
Exception occurs, when you assign an array which is not compatible with the
data type of that array
|
Array
Index Out Of Bounds Exception
|
These
Exception occurs, when you assign an array which is not compatible with the
data type of that array
|
Null
Pointer Exception
|
These
Exception occurs, when you try to implement an application without
referencing the object and allocating to a memory
|
Number
Format Exception
|
These
Exception occurs, when you try to convert a string variable in an incorrect
format to integer (numeric format) that is not compatible with
each other
|
Negative
ArraySizeException
|
These
are Exception, when you declare an array of negative size.
|
Rule of thumb:
Unchecked exceptions occur when there are logic
errors with your program. Things that you as a programmer got wrong, and are
able to fix in your own code (like dividing by zero, or going out of bounds on
an array).
Checked exceptions come up when there are things that can go wrong
that you can't control, like opening a file that doesn't exist, or making a
connection to a server that isn't responding, etc.
--------------------------------------------------------------------------
Exception Propagation
Method call stack
ExceptionDemo.method4 <--- Exception occurs
ExceptionDemo.method3
ExceptionDemo.method2
ExceptionDemo.method1
ExceptionDemo.main
If not handled in any method, the exception is thrown and the application will stop
public class ExceptionDemo {
public void method4(){
int a=7;
int b=0;
int c=a/b;
}
public void method3(){
this.method4();
System.out.println("After method
4 completion");
}
public void method2(){
this.method3();
System.out.println("After method
3 completion");
}
public void method1(){
this.method2();
System.out.println("After method
2 completion");
}
public static void main(String[] args){
ExceptionDemo
ex = new ExceptionDemo();
ex.method1();
System.out.println("After method
1 completion");
}
}
Exception in thread "main" java.lang.ArithmeticException: / by zero
at
ExceptionDemo.method4(ExceptionDemo.java:7)
at
ExceptionDemo.method3(ExceptionDemo.java:11)
at
ExceptionDemo.method2(ExceptionDemo.java:16)
at
ExceptionDemo.method1(ExceptionDemo.java:22)
at
ExceptionDemo.main(ExceptionDemo.java:34)
-------------------------------------------------------------------------------------------------
public class ExceptionDemo {
public void method4(){
int a=7;
int b=0;
int c=a/b;
}
public void method3(){
this.method4();
System.out.println("After method
4 completion");
}
public void method2(){
this.method3();
System.out.println("After method
3 completion");
}
public void method1(){
try{
this.method2();
System.out.println("After method
2 completion");
}
catch(Exception e)
{
System.out.println(e.getMessage());
}
}
public static void main(String[] args){
ExceptionDemo
ex = new ExceptionDemo();
ex.method1();
System.out.println("After method
1 completion");
}
}
/ by zero
After method 1 completion-----------------------------------------
Writing own exception
public class MyCheckedException
extends Exception{
public
MyCheckedException(String msg){
super(msg);
}
public
MyCheckedException(String msg, Throwable t){
super(msg,t);
}
}