Exception Handling and Checked and Unchecked Exception

Exceptions in Java - What are Java Exceptions?
A Java Exception is an abnormal condition that arises during the execution of a program and also called a run-time error. An exception in Java signals the unusual or catastrophic situations that can arise.
Examples of Java Exceptions are:
  • Incorrect user input such as division by zero
  • File that needs to be opened not found
  • Network connection problem
Types of Java Exceptions
Like anything else in this world, Exceptions can also be categorized! Based on whether or not you are required to handle the exception, there are two types of exceptions:
  1. Checked Exceptions
  2. Unchecked Exceptions.
Checked Exceptions: These are the type of exceptions for which the compiler checks to ensure that your code is prepared for handling such exceptions. These are the exceptions that you can expect to occur frequently and you must handle them in your code. The conditions that generate such exceptions are generally outside the control of your program and they can occur in a correct program. But you can anticipate them and thus you must write code to deal with them. Programmatically, checked exceptions are the instances of the Exception class or one of its subclasses, excluding RuntimeException subtree.

List of checked exception
  • ClassNotFoundException Class not found.
  • CloneNotSupportedException Attempt to clone an object that does not implement theCloneable interface.
  • IllegalAccessException Access to a class is denied.
  • InstantiationException Attempt to create an object of an abstract class or interface.
  • InterruptedException One thread has been interrupted by another thread.
  • NoSuchFieldException A requested field does not exist.
  • NoSuchMethodException A requested method does not exist.
Unchecked Exceptions: The compiler does not check for such type of exceptions. Unchecked Exceptions comprise of run time exceptions (of type RuntimeException or its subclasses) and errors (of type Error or its subclasses). Runtime Exceptions occur due to program bugs and include exceptions such as division by zero and invalid array indexing. You can not recover from an unchecked exception and you are not required to handle such type of exceptions either, but still you can do so if you want. ArithmeticException class is an example of unchecked exception. Errors are the exceptions that are not expected to be caught under normal circumstances by your program. They are used by the Java run time environment to indicate errors related to run time environment itself. Stack Overflow is an example of error.

List of unchecked exception
  • ArithmeticException Arithmetic error, such as divide-by-zero.
  • ArrayIndexOutOfBoundsException Array index is out-of-bounds.
  • ArrayStoreException Assignment to an array element of an incompatible type.
  • ClassCastException Invalid cast.
  • IllegalArgumentException Illegal argument used to invoke a method.
  • IllegalMonitorStateException Illegal monitor operation, such as waiting on an unlocked thread.
  • IllegalStateException Environment or application is in incorrect state.
  • IllegalThreadStateException Requested operation not compatible with current thread state.
  • IndexOutOfBoundsException Some type of index is out-of-bounds.
  • NegativeArraySizeException Array created with a negative size.
  • NullPointerException Invalid use of a null reference.
  • NumberFormatException Invalid conversion of a string to a numeric format.
  • SecurityException Attempt to violate security.
  • StringIndexOutOfBounds Attempt to index outside the bounds of a string.
  • UnsupportedOperationException An unsupported operation was encountered.



Common scenarios of Exception Handling where exceptions may occur
There are given some scenarios where unchecked exceptions can occur. They are as follows:
1) Scenario where ArithmeticException occurs
If we divide any number by zero, there occurs an ArithmeticException.

int a=50/0;//ArithmeticException

2) Scenario where NullPointerException occurs

If we have null value in any variable, performing any operation by the variable occurs an NullPointerException.

String s=null;
System.out.println(s.length());//NullPointerException
3) Scenario where NumberFormatException occurs
The wrong formatting of any value, may occur NumberFormatException. Suppose I have a string variable that have characters, converting this variable into digit will occur NumberFormatException.

String s="abc";
int i=Integer.parseInt(s);//NumberFormatException
4) Scenario where ArrayIndexOutOfBoundsException occurs
If you are inserting any value in the wrong index, it would result ArrayIndexOutOfBoundsException as shown below:

int a[]=new int[5];
a[10]=50; //ArrayIndexOutOfBoundsException

Exceptions Methods:
Following is the list of important methods available in the Throwable class.



SNMethods with Description
1public String getMessage()
Returns a detailed message about the exception that has occurred. This message is initialized in the Throwable constructor.
2public Throwable getCause()
Returns the cause of the exception as represented by a Throwable object.
3public String toString()
Returns the name of the class concatenated with the result of getMessage()
4public void printStackTrace()
Prints the result of toString() along with the stack trace to System.err, the error output stream.
5public StackTraceElement [] getStackTrace()
Returns an array containing each element on the stack trace. The element at index 0 represents the top of the call stack, and the last element in the array represents the method at the bottom of the call stack.
6public Throwable fillInStackTrace()
Fills the stack trace of this Throwable object with the current stack trace, adding to any previous information in the stack trace.




<<Previous <<   || Index ||   >>Next >>


No comments:

Post a Comment