Error & Exception
Error is thrown by JVM in a scenario which is fatal and there is no way for the application program to recover from that error.
- Unchecked type: Errors happen at run time. They will not be known to compiler
- Cannot recover
- eg. java.lang.StackOverflowError, java.lang.OutOfMemoryError
Exception is an event that disrupts the normal flow of the program. It is an object which is thrown at runtime.
- Unchecked & Checked type: checked exceptions are known to compiler where as unchecked exceptions are not known to compiler because they occur at run time.
- Can recover from exceptions by handling then through try-catch blocks.
Types of exceptions
- Checked Exception: The classes that extend Throwable class except RuntimeException and Error are known as checked exceptions. Checked Exceptions are checked at compile-time.
- e.g.IOException, SQLException etc.
- Unchecked Exception: Unchecked exceptions are not checked at compile-time rather they are checked at runtime.
- e.g. ArithmeticException, NullPointerException, ArrayIndexOutOfBoundsException etc.
Unchecked Exception scenarios
- ArithmeticException: If we divide any number by zero, there occurs an ArithmeticException.
int a = 50/0;
- NullPointerException: 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());
- NumberFormatException: 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);
- ArrayIndexOutOfBoundsException: 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;
Handling checked exceptions
Due to compilation error, checked exceptions need to be handled by programmer. There are two ways to handle these exceptions.
- Throw when declaring method
- Try, catch, and finally inside the method
Throw when declaring method: Toss the exception handling to user when using the method.
public void connect() throws MyException{ // try ~ catch ~ finally will not be used }
Try, catch, and finally inside the method: Handling exception inside the method
public void connect(){ try{ // Do work here System.out.println(10/0); } catch (MyException e){ // Catch lower Exception first } catch (Exception e){ // Highest Exception at the end // There are three ways to see the excetption e.printStackTrace(); System.out.println(e.toString()); System.out.println(e.getMessage()); } finally { // Code on here will be always printed } }
- e.printStackTrace(): Name of the Exception, Message of the Exception, Stack trace
- On example code above:
java.lang.ArithmeticException: /by Zero at main()
- e.toString(): Name of the Exception, Message of the Exception
- On example code above:
java.lang.ArithmeticException: /by zero
- e.getMessage(): Message of the Exception
- On example code above:
/by zero
Creating your own Exception
Extends Exception classe: you can make the most suitable exception for your program.
public class MyException extends Exception{ public Myexception(String msg){ super(msg); } }