Difference Between An Error And Exception in Java

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:

1. Using a negative size in an array.
2. Conversion of a string into a number.
3. Divide an integer by zero.
4. Access an element that is out of bounds of an array
5. Store a value that is of incompatible data type in an array.
6. Cast an instance of base class to one of its derived classes.
7. Using a null object to reference an object's member.
8. Capitalization of keywords.
9. Missing brackets in a no-argument message.
10. 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

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:

1. Checked
2. Runtime/unchecked
3. 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