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

Java exception handling example analysis, I believe that many inexperienced people do not know what to do, so this article summarizes the causes of the problem and solutions, through this article I hope you can solve this problem.

The Throwable class is a superclass of all errors or exceptions in the Java language (two direct subclasses: Error and Exception)

Error vs Exception

The abnormal events that occur during the execution of Java programs can be divided into two categories:

Error:Error class objects are generated and thrown by the Java virtual machine, and most errors are independent of the actions performed by the code writer. For example, a Java virtual machine running error (Virtual MachineError) occurs when the JVM no longer has the memory resources needed to continue the operation. When these exceptions occur, the Java virtual machine (JVM) generally chooses thread termination; and when the virtual machine attempts to execute the application, such as class definition error (NoClassDefFoundError), link error (LinkageError). These errors are untraceable because they are outside the control and processing power of the application, and the vast majority are conditions that are not allowed to occur while the program is running. For a well-designed application, even if an error does occur, you should not essentially try to deal with the exception caused by it. In Java, errors are usually described using subclasses of Error.

Exception: in the Exception branch, there is an important subclass RuntimeException (runtime exception). This type of exception automatically defines exceptions such as ArrayIndexOutOfBoundsException (array subscript out of bounds), NullPointerException (null pointer exception), ArithmeticException (arithmetic exception), MissingResourceException (lost resources), ClassNotFoundException (class not found) and other exceptions written by you. These exceptions are not checked, and can be captured or not handled in the program. These exceptions are generally caused by program logic errors, and programs should avoid such exceptions as far as possible from a logical point of view; while exceptions outside RuntimeException are collectively referred to as non-runtime exceptions, which belong to the Exception class and its subclasses, and must be handled from the point of view of program syntax. If not handled, the program cannot be compiled and passed. For example, IOException, SQLException, and user-defined Exception exceptions are not customized to check for exceptions.

The difference between Error and Exception: Error is usually a catastrophic and fatal error that cannot be controlled and handled by the program. When these exceptions occur, the Java virtual machine (JVM) generally chooses to terminate the thread; Exception can usually be handled by the program, and these exceptions should be handled as much as possible in the program.

Check for exception vs is not checked for exception

Check for exceptions: in the correct process of running the program, it is easy to occur, reasonable and tolerable abnormal conditions, to a certain extent, the occurrence of this kind of exception is predictable, and once this kind of exception occurs, it must be dealt with in some way.

Except for RuntimeException and its subclasses, other Exception classes and their subclasses belong to check exceptions. When such exceptions may occur in the program, either use the try-catch statement to catch or throw with the throws clause, otherwise the compiler will not pass.

Unchecked exceptions: including RuntimeException and its subclasses and Error.

An unchecked exception is an exception that the compiler does not require mandatory handling, while checking an exception is an exception that the compiler requires that it must handle.

Exception handling keyword

Java exception handling involves five keywords: try, catch, finally, throw, and throws.

Try: used for monitoring. The code to be listened for (the code that may throw an exception) is placed within the try statement block, and when an exception occurs within the try statement block, the exception is thrown.

Catch: used to catch exceptions. Catch is used to catch exceptions that occur in try statement blocks. -finally:finally statement blocks are always executed. It is mainly used to recover material resources (such as database connections, network connections and disk files) opened in try blocks. Only after the execution of the finally block, will you come back to execute the return or throw statements in the try or catch blocks. If the statements with termination methods such as return or throw are used in the finally, the execution will not be skipped back and will be stopped directly.

Throw: used to throw an exception.

Throws: used in method signatures to declare exceptions that may be thrown by the method.

Note: if try is followed by multiple catch, then a small range of exceptions comes first, and a large range of exceptions comes after (according to the principle of polymorphism, if the large one is in front of it, all subclass objects will be received, and the subsequent catch will be meaningless.)

The difference between final, finally and finalize

Final can be used to modify classes, methods, variables, have different meanings, final modified class represents can not inherit extensions, final variables can not be modified, and final methods can not be rewritten (override).

Finally is a mechanism by which Java ensures that key code must be executed. We can use try-finally or try-catch-finally to do things like closing the JDBC connection, keeping the unlock lock, and so on.

Finalize is a method of the base class java.lang.Object, which is designed to ensure that objects complete the collection of specific resources before being garbage collected. The finalize mechanism is no longer recommended and has been marked as deprecated since JDK 9.

When resources such as closed connections are needed, it is more recommended to use the try-with-resources statement added in Java 7 than finally, because the Java platform can usually handle exception cases better and encode much less. If you do need extra processing, consider the Cleaner mechanism provided by Java or other alternatives.

If JVM exits before executing to finally, such as System.exit (0), the finally code will not execute

If there is a return statement in catch, will the code in finally still be executed?

Code example:

Class FinallyDemo {public static void main (String [] args) {System.out.println (getInt ());}

Public static int getInt () {int a = 10; try {System.out.println (a / 0); a = 20;} catch (ArithmeticException e) {a = 30; return a;} finally {a = 40; return axi1;} / / return a;}}

The above experimental code can answer all the questions.

If finally does not have return, catch will run finally's logic before running return, and then jump back to catch's return to output 30.

If finally has return, catch will run finally's logic before running return, and then run finally's return directly to output 41.

Abnormal precautions

A subclass cannot throw an exception that the parent class does not have. The exception thrown by the subclass is the same as that thrown by the parent class or is a subclass of the exception thrown by the parent class

If the method overridden in the parent class does not throw an exception, then the method of the subclass must not throw an exception. If an exception occurs in a subclass, then the subclass can only try, not throws

After reading the above, have you mastered the method of sample analysis of Java exception handling? If you want to learn more skills or want to know more about it, you are welcome to follow the industry information channel, thank you for reading!

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.