Differences between Runtime/Checked/Unchecked/Error/Exception

Question

What are the Runtime exceptions and what are Checked/Unchecked Exceptions and difference between Error/Exception.Why these many types? Instead Java may simply follow a simpl

Answer 1

This article sumarizes Checked and Unchecked exceptions in a clear and concise way.

• Checked Exceptions: Checked Exceptions are the exceptions which can be detected, identified and checked at compile time. If a code block throws a checked exception then the method must handle the exception or it must specify the exception using throws keyword.

  • Example:

    public void testDB() throws ClassNotFoundException, SQLException
    {
        Class.forName("com.mysql.jdbc.Driver");
        System.out.println("Driver Loaded");
        Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/selenium","root","root");
        System.out.println("Connected to MySQL DB");
    }
    

  • We either need to specify list of exceptions using throws or we need to use try-catch{} block. I have demonstrated the useage of throws in the below program.

• Unchecked Exceptions: Unchecked Exceptions are not checked at compiled time. Java exceptions under Error and RuntimeException classes are unchecked exceptions and everything else under throwable is checked.

Summary: If a client can reasonably be expected to recover from an exception, make it a checked exception. If a client cannot do anything to recover from the exception, make it an unchecked exception.

Answer 2

Exceptions are two types in java:

1. **Checked Exception: The exceptions which are checked by compiler. 

For example: we you are performing operation with file, then compiler will ask you to handle IOException either by try-catch block or throws keyword.

2. Unchecked Exception: The exceptions which are not checked by compiler at run time. 

For example: If you are performing operation on an object without creating it; in this case you'll get NullPointerException.

Answer 3

Throwable is at the top off all exceptions. Underneath Throwable you have Error and Exception. Underneath Exception you have RuntimeException.

Java has two types of exceptions - checked and unchecked. Checked exceptions are enforced by the compiler (you have to declare them in the throws clause and catch them eventually). Unchecked exceptions are not enforced for catching or declaring in throws clause.

(Controversial part of the answer)

Throwable exists so that there is a parent for all exception types. You should never declare that you throw Throwable and never catch it (unless you really really really know what you are doing).

Error exists to indicate issues with the runtime environment, things that your program probably cannot recover from, such as a badly formatted class file or the VM running out of memory. You should not catch an Error unless you really know what you are doing.

Exception exists as the root for all non-programmer errors (see RuntimeException for the "exception" to this) , such as a file cannot be created because the disk is full. You should not throw, throws, or catch Exception. If you have to catch Exception make sure you know what you are doing.

RuntimeException exists to indicate all programmer error, such as going past the end of an array or calling a method on a null object. These are things that you should fix so that they do not throw exceptions - the indicate that you, the programmer, screwed up the code. Again, you should not catch these unless you know what you are doing.

Answer 4

Runtime Exceptions provide you with the flexibility to avoid catching, declaring the exceptions.

Answer 5

TofuBeer's answer explains clearly what the exception classes mean.

Why these many types? Instead Java may simply follow a simple design(just try/catch all types) to handle an abnormal condition in a program?

Why? Because they are necessary! Without those 4 classes, handling exceptions by broad category would be impractical.

• How would you catch "all fatal JVM errors" without the Error class?
• How would you catch "all exceptions that are not JVM fatal errors" without the Exception class?
• How would you catch "all unchecked exceptions" without the RuntimeException class?

Answer 6

• Error (throws by VM, should not be caught or handled)
  1. VM Error
  2. Assertion Error
  3. Linkage Error ...so on
• Runtime/Uncheck Exception(programming error, should not be caught or handled)
  1. NullPointerException
  2. ArrayIndexOutOfBoundException
  3. IllegalArgumentException ... so on
• Check Exception(Anything Else, Applications are expected to be caught or handled)
  1. IOException
  2. FileNotFoundException
  3. SQLException ...so on