运行时/已检查/未检查/错误/异常之间的差异

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 simple design(just try/catch all types) to handle an abnormal condition in a program?

Answer 1

Since I am a new Java developer, I have also faced some difficulties for distinguishing and dealing with different types of exceptions. That is why I have made a short note on this topic, and whenever I get confused I go through it. Here it is with the image of the Throwable class hierarchy:

[image courtesy of JavaTpoint ].

There are three key classes to remember here: Throwable , Exception and Error . Among these classes Exception can be divided into two types: "Checked Exception" and "Unchecked Exception".

Checked Exception:

• These are the classes that extend Throwable except RuntimeException and Error .
• They are also known as compile time exceptions because they are checked at compile time, meaning the compiler forces us to either handle them with try/catch or indicate in the function signature that it throws them and forcing us to deal with them in the caller.
• They are programmatically recoverable problems which are caused by unexpected conditions outside the control of the code (eg database down, file I/O error, wrong input, etc).
• Example: IOException , SQLException , etc.

Unchecked Exception:

• The classes that extend RuntimeException are known as unchecked exceptions.
• Unchecked exceptions are not checked at compile-time, but rather at runtime, hence the name.
• They are also programmatically recoverable problems but unlike checked exception they are caused by faults in code flow or configuration.
• Example: ArithmeticException , NullPointerException , ArrayIndexOutOfBoundsException , etc.
• Since they are programming errors, they can be avoided by nicely/wisely coding. For example "dividing by zero" produces an ArithmeticException , which can be avoided by a simple check on the divisor. Similarly we can avoid NullPointerException by simply checking the references: if (object != null) or even using better techniques .

Error:

• Error refers to an irrecoverable situation that is not being handled by a try/catch .
• Example: OutOfMemoryError , VirtualMachineError , AssertionError , etc.

Why are these many types?

In addition to Stephen C 's answer I want to say: exception handling is a relatively expensive operation in Java. We should not put all exceptional situation in a try/catch block. Excessive use of try/catch s may hamper program performance.

In conclusion, Exception s should be handled programmatically whenever possible. On the other hand, we cannot handle Error s, so these might be some logical reasons why there are many types of exceptions.

Answer 2

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 3

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 4

• 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

Answer 5

Difference between Checked and unchecked exceptions:

We have many differences between checked and unchecked exception but all the differences originate from once basic consideration that whether the exception is solvable by compiler or not.

Points to remember are:

[1] Checked exception means Compiler checked Exceptions . It means that compiler mandates that such exception to be handled by try-catch block or throws keyword.

[2] Unchecked exceptions are the ones for which compiler doesn't provides any mandate as they can be resolved by developer by coding/programing as the control flow is controllable like in ArithmeticException, NullPointerException ArrayIndexOutOfBoundsException, IllegalArgumentException ,etc.

I call it “Exception-Identity-Test” where you take any random exception from java doc and just ask it one question. “Hey Exception! Can you be solved programmatically?”

If the exception says YES then it is an Unchecked Exception as this can be solved by either code change or resolving some calculation mistake etc.

On the other hand if the Exception says No then this is Checked Exception as in checked Exception control flow goes out of our code like if someone changes Database passwords or someone unplugs the network cable ,connection timeout (ConnectException), some resource is not found (FileNotFoundException, ClassNotFound), SQLException, InvocatonTargetException etc. These ones cannot be resolved by programming

Answer 6

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 7

The figure ‎below shows the hierarchy of the Exception classes. The base class for all Exception objects is java.lang.Throwable , together with its two subclasses java.lang.Exception and java.lang.Error .

• The Error class describes internal system errors (eg, VirtualMachineError , LinkageError ) that rarely occur. If such an error occurs, there is little that you can do and the program will be terminated by the Java runtime.

• The Exception class describes the error caused by your program (eg FileNotFoundException , IOException ). These errors could be caught and handled by your program (eg, perform an alternate action or do a graceful exit by closing all the files, network and database connections).

Checked vs Unchecked

As illustrated, the subclasses of Error and RuntimeException are known as unchecked exceptions. These exceptions are not checked by the compiler, and hence, need not be caught or declared to be thrown in your program. This is because there is not much you can do with these exceptions. For example, a "divide by 0" triggers an ArithmeticException , array index out-of-bound triggers an ArrayIndexOutOfBoundException , which are really programming logical errors that shall be been fixed in compiled-time, rather than leaving it to runtime exception handling.

All the other exception are called checked exceptions. They are checked by the compiler and must be caught or declared to be thrown.

RuntimeException and its subclasses are not checked by the compiler and need not be declared in the method's signature. Therefore, use them with care, as you will not be informed and may not be aware of the exceptions that may occur by using that method (and therefore do not have the proper exception handling codes) – a bad software engineering practice.

The source is here

Answer 8

运行时异常为您提供了避免捕获和声明异常的灵活性。

Answer 9

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.