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

Today, I will talk to you about the difference between NoClassDefFoundError and ClassNotFoundException. Many people may not know much about it. In order to make you understand better, the editor has summarized the following for you. I hope you can get something according to this article.

Common answers to the difference between NoClassDefFoundError and ClassNotFoundException

NoClassDefFoundError is an Error,Error that in most cases represents a fatal error that cannot be recovered from the program. The reason is that the JVM or ClassLoader class loader cannot find the required class definition under classpath at run time (the compilation time can be found normally, so unlike ClassNotFoundException, this is a runtime Error). At this time, the virtual machine will throw NoClassDefFoundError, usually because some classes have been left out in the packaging process. Or the jar package is damaged or tampered with, and the corresponding Class is not available in classpath, and so on.

ClassNotFoundException is a run-time exception belonging to Exception, and most of them are exception types that can be recovered from the code. Most of the reasons for this exception are due to the dynamic loading of class information using the Class.forName () method, but this class is not found in the classpath, so a ClassNotFoundException will be thrown at run time.

The above is the general difference between NoClassDefFoundError and ClassNotFoundException, so you can extend it to explore Error and Exception in the Java type system.

The difference between Error and Exception

Both Error and Exception inherit the Throwable class, which reflects the classification of exceptions by Java designers. In Java, only instances of the Throwable class can be caught or thrown by try/catch.

Error represents programs with fatal and unrecoverable errors in most cases. Most of them are unpredictable errors that are not needed and cannot be caught and thrown, such as the common OutOfMemeryError,StackOverFlowError and the NoClassDefFoundError mentioned in this article. They are all subclasses of Error.

Exception belongs to program errors, most of which are caused by artificial coding, and most of them can be predicted or processed to make the program flow normally, so it is necessary to capture (try/catch) or declare to throw (throw). Exception is also divided into two cases: check exception checked exception (compile-time exception) and non-check exception unchecked exception (run-time exception).

Detectable exceptions are exceptions that must be displayed at compile time, and the compiler will force them to be handled, otherwise the compiler will not pass. Non-checked exceptions are exceptions that occur when the program is running, and most of them are program problems that programmers cannot handle, such as the common NullPointerException,ArrayIndexOutOfBoundsException. The ClassNotFoundException in the title of this article belongs to compile-time exceptions, which need to be handled forcefully when using Class.forName.

A picture is worth a thousand words. In order to make it easier for you to feel it intuitively, I probably drew a simple exception architecture diagram for reference only:

Considerations for using exceptions

Is there anything you need to pay attention to when the operation is abnormal? Let's start with a simple code example.

Try {/ / Business Code / / something happened Thread.sleep;} catch (Exception e) {} / / Business Code

What are the obvious mistakes made by the above code? Let me give you a brief list:

Catching exceptions should use a specific type of Exception

No exception handling is performed.

Why catch specific types of exceptions? There are mainly the following points because your code will be read by many people on the team. The broad use of Exception to handle all exceptions will make it difficult for others to understand the exceptions of your code, and the main purpose of the program is to reflect its semantics. For example, if Thread.sleep explicitly throws InterruptedException,Class.forName and explicitly throws ClassNotFoundException, then you should explicitly handle such clear exceptions as InterruptedException,ClassNotFoundException, instead of generally using Exception to wrap all exceptions.

The problem that there is no handling of the exception is actually more serious than the above, this kind of behavior is essentially covering up the problem, which will not only lead to all kinds of strange problems, but also have no clues to track at all. no one can guess where the program went wrong, resulting in a very inefficient location problem, so if no exception is thrown, at least put the corresponding error information into the log Instead of "swallowing" abnormalities, artificial obstacles are set for diagnosis.

Summary

Through a simple problem of the difference between NoClassDefFoundError and ClassNotFoundException and a simple exception handler demo, we draw out the exception system of Java and different classifications and precautions for exception handling at ordinary times.

In addition, it is recommended that you try to use the unified exception handling mechanism in practice. For example, Spring provides several global exception handling mechanisms:

Implement the HandlerExceptionResolver interface

Within Controller, use the @ ExceptionHandler annotation to handle exceptions

Global Controller exception handling annotation @ ControllerAdvice, which can handle specific exceptions according to type

After reading the above, do you have any further understanding of the difference between NoClassDefFoundError and ClassNotFoundException? If you want to know more knowledge or related content, please follow the industry information channel, thank you for your support.

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.