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

This article will explain in detail the relevant knowledge points about java exception handling for you. The editor thinks it is very practical, so I share it with you as a reference. I hope you can get something after reading this article.

Overview of exceptions

In Java, some of these errors that may occur while the program is running are called exceptions. An exception is an event that occurs during program execution, which interrupts the normal flow of instructions that are being executed.

Video notes:

Exceptions encountered during execution of the Java program:

Java.lang.Error: generally do not write targeted code to deal with

Java.lang.Exception: exception handling is possible

Compile-time exception (checked) and runtime exception (unchecked)

Serious problems that cannot be solved by the 1.Error:java virtual machine. For example, JVM system internal error

2.Exception: other general problems caused by programming errors or accidental external factors can be dealt with with targeted code. For example: null pointer access, trying to read files that do not exist, network connection is interrupted, array corner marks are out of bounds

Let's take a look at the most common time when divisor 0

Public class test {public static void main (String [] args) {int axi3max 0; System.out.println (a);}}

The result of running the program reports that an arithmetic exception ArithmeticException has occurred, and the system is no longer executing and ends ahead of time. This situation is what we call an anomaly.

Public class test {public static void main (String [] args) {main (args);}}

Stack overflow (main (args) is also called in main)

Public class test {public static void main (String [] args) {Integer [] a=new Integer [1024,1024,1024];}}

Heap overflow (OutOfMemoryError)

The contents of the book:

The Java language is an object-oriented programming language, so exceptions also appear as instances of classes in the Java language. When an error occurs in a method, this method creates an object and passes it to the running system. This object is the exception object. Through the exception handling mechanism, the abnormal handling code can be separated from the main logic of the program, that is, exceptions can be handled elsewhere while writing the main process of the code.

Examples of common exceptions null pointer exception NullPointerExceptionpublic class test {public static void main (String [] args) {int a [] = null; System.out.println (a [5]);}}

Array angle mark out of bounds exception ArrayIndexOutOfBoundsExceptionpublic class test {public static void main (String [] args) {int a [] = new int [5]; System.out.println (a [5]);}}

Throwing and catching of exceptions

In order to ensure the effective execution of the program, the exception thrown needs to be handled accordingly. In Java, if a method throws an exception, you can either catch it in the current method and then handle the exception, or you can throw the exception up and leave it to the method caller.

Throw an exception

After the exception is thrown, if nothing is done, the program will be terminated.

For example, converting a string to an integer can be done through the parseInt () method of the Integer class. But if the string is not in numeric form, the parseInt () method throws an exception and the program terminates where the exception occurs and does not execute the following statement

Public class test {public static void main (String [] args) {String str= "abc"; System.out.println (str); int a=Integer.parseInt ("20L"); System.out.println (a);}}

NumberFormatException exceptions, abc, and output are just problems with the following statements themselves, causing the code to terminate

An exception is thrown and the subsequent code does not execute

Catch exception

The exception capture structure of Java language consists of try,catch,finally3 part. Among them, the try statement block stores the Java statement that may cause exceptions; the catch statement block is used to fire the caught exception after the try statement block; the final statement block is the last executive part of the exception structure, no matter how the code in the try statement block exits, the finally statement block will be executed

Try {/ / Code block} catch (exception1 e) / / (exception type, variable name) {/ / one pair of exception1 handling} catch (exception type, variable name) {/ / one pair of exception2 processing} finally {/ / code block (code that must be executed)}

The template is as above

Public class test {public static void main (String [] args) {String str= "abc"; System.out.println (str); try {int a=Integer.parseInt (str); System.out.println ("guess");} catch (Exception e) {System.out.println ("abnormal, don't panic") } System.out.println ("you see, it's not a problem");}}

After outputting the exception property with the e.printStackTrace (); statement, you get

Video notes:

Finally is optional

Use try to wrap the possible exception code. In the process of execution, once an exception occurs, an object corresponding to the exception class will be generated. According to the type of the object, go to catch to match-for example, Exception e in our above code is written as NumberFormatException e, corresponding to it.

Once the exception object in the try matches to a catch, it goes into the catch for exception handling. Once the processing is complete, jump out of the current try--catch structure (if there is no finally at this time). Continue to execute subsequent code

If the exception type in catch satisfies the child parent class relationship, then the child class must be declared above the parent class.

Variables declared in the try structure can no longer be called after the try structure

When using this structure to handle exceptions, there is no error at compile time, but errors may still be reported at run time, which is equivalent to extending the exception to the runtime. In development, because runtime exceptions are common, we usually do not write try-catch-finally for runtime exceptions.

Finally statement block

In the following four special cases, the finally block is not executed:

An exception occurred in the finally statement block

The System.exit () exit program was used in the previous code

The thread in which the program is located dies

Close CPU

By comparing here, it is found that the second picture does not write finally but does not affect the result.

Finally is optional

What is declared in finally is the code that must be executed. Even if there is another exception in catch, there are return statements in try, return statements in catch, and so on. Use the throws keyword to throw an exception in a method.

The throws keyword is usually used when declaring a method to specify the exceptions that the method may throw. Multiple exceptions can be separated by commas.

Public class test {static void p () throws NegativeArraySizeException {/ / defines a method and throws a NegativeArraySizeException exception int [] a=new int [- 4];} public static void main (String [] args) {try {p () } catch (NegativeArraySizeException e) {System.out.println ("exception thrown by p () method");}

Note: if it is an Error class, a RuntimeException class, or their subclasses, you can declare the exception to be thrown without using the throws keyword. The compilation will still pass smoothly, but it will be thrown by the system at run time. "

The throws+ exception type is written at the declaration of the method. Indicates that an exception type may be thrown when this method is executed. Once an exception occurs when the method body executes, an exception class object is still generated at the exception code. When this object satisfies the post-throws exception type, it will be thrown.

Use the throw keyword to throw an exception (custom exception)

The throw keyword is usually used in the method body and an exception object is thrown. The program terminates immediately when it executes the throw statement, and none of its subsequent statements are executed. After an exception is thrown through throw, if you want to catch and handle the exception in the higher-level code, you need to use the throws keyword in the method that throws the exception to indicate the exception to be thrown in the method declaration; if you want to catch the exception thrown by throw, you must use the try-catch statement block

Public class test extends Exception {String name; public test (String errorname) {name=errorname;} public String getName () {return name;}} public class captor {static int q (int x Mint y) throws test {if (y)

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.