Shulou(Shulou.com)06/02 Report--

In this article, the editor introduces in detail "what are the knowledge points about anomalies in Java", the content is detailed, the steps are clear, and the details are handled properly. I hope that this article "what knowledge points about anomalies in Java" can help you solve your doubts.

3W principle

There are 3W principles everywhere, and JAVA exceptions can also summarize 3W:what, where, and why.

What corresponds to the exception type: what is answered and thrown

Where corresponds to exception stack trace: answered where to throw

Why corresponding exception message: answered why it was thrown

Abnormal system

In the figure above, we can see that Throwable is an abnormal * class, and Error and Exception are its subclasses.

Exception is divided into RuntimeException and non-RuntimeException subcategories.

The difference between Error and Exception

Let's take a look at their conceptual definition:

(1) Error: the compiler does not check for system errors that the program cannot handle.

Error indicates a fatal error in the system that the program cannot handle. Generally, there are problems related to JVM, such as system crash, memory overflow, method call stack overflow and so on, such as StackOverflowError, OutOfMemoryError, which are often encountered. This type of error, which is not checked by the compiler, occurs while the system is running.

These errors cannot be dealt with and prevented by our program itself, and it is suggested that the program should be terminated and restarted directly.

(2) Exception: an exception that can be handled by a program and can be handled after being caught.

Exception exceptions can be caught and handled by the program. We should handle them as much as possible to keep the program running rather than aborting the program.

To sum up, Error is an error that the program cannot handle, and Exception is an exception that can be handled.

The difference between RuntimeException or not

There are two types of exceptions to Exception in the figure above. Let's take a look.

(1) RuntimeException: unpredictable, the program should avoid on its own

What is unpredictable? Such as: array subscript out of bounds, access object null pointer and so on, this kind of exception is our partners should try to avoid when writing programs. That is, we programmers can avoid it.

For example, for null pointer exceptions, we should add null pointer judgment to if (obj = = null) when programming, so as to avoid null pointer exceptions.

(2) non-RuntimeException: predictable exceptions that can be checked by the compiler

It can be predicted, for example, when we open a file, such as there is no referenced exception in the file.

This exception compiler will check it out and must be handled.

This is also known as the Checked Exception exception type

Responsibility attribution

Let's look at it from the perspective of responsibility:

Error belongs to the responsibility of JVM.

RuntimeException is the responsibility of the program.

Non-RuntimeException (CheckedException) detectable exception is the responsibility of JAVA compiler

The above code is a little more intuitive:

We see that the Error and RuntimeException compilers are not checked, while the CheckedExcepton exception compiler is checked, that is, we programmers have to capture processing. What should I do with it?

(1) try-catch mode

If you catch this exception in try-catch, you can handle the exception logically in the catch code snippet, depending on the actual business. If the above code is a FileNotFound exception, according to this type, we know that the file handle does not exist, then what we should do. For example, remind the user that the file does not exist

(2) the way to throw an exception

In complex business, modules written by our programmers themselves are likely to be referenced by modules written by other programmers. In order to let other programmers know about the exceptions of our modules and ask them to handle them, we can use the method of throwing exceptions.

Let's take a look at the handling of upper-level calls.

We see that the upthrow exception needs to be handled by the caller. What is the way to deal with it? In fact, it is the try-catch mentioned above or continue to throw.

Common Error and Exception

(1) RuntimeException

NullPointerException-null pointer reference exception

ClassCastException-Type cast exception

IllegalArgumentException-pass illegal parameter exception

IndexOutOfBoundsException-subscript out of bounds exception

NumberFormatException-numeric format exception

(2) non-RuntimeException

ClassNotFoundException-specified class exception not found

IOException-IO operation exception

(3) Error

NoClassDefFoundError-cannot find the exception defined by class

StackOverflowError-Deep recursive exception that causes stack exhaustion to be thrown

OutOfMemoryError-memory overflow exception

After reading this, the article "what are the knowledge points about anomalies in Java" has been introduced. If you want to master the knowledge points of this article, you still need to practice and use it yourself to understand it. If you want to know more about related articles, welcome to follow the industry information channel.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.