Exception in Java, also known as exception, is an event that occurs during program execution, which interrupts the normal instruction flow of the executing program. In order to handle running errors in the program promptly and effectively, exception classes must be used.

Exception introduction

In a program, errors may occur from various situations that the programmer did not expect, or from circumstances beyond the programmer's control, such as users bad data, trying to open a non-existent file, etc. In order to handle running errors in the program promptly and effectively, Java specifically introduced the exception class.

Example 1

In order to better understand what an exception is, let’s look at a very simple Java program. The following sample code allows the user to enter an integer within 1~3, and prompts an input error in other cases.

package ch11;
import Java.util.Scanner;
public class TestO1
{
    public static void main(String[] args)
    {
        System.out.println("請輸入您的選擇：（1~3 之間的整數(shù)）");
        Scanner input=new Scanner(System.in);
        int num=input.nextInt();
        switch(num)
        {
            case 1:
                System.out.println("one");
                break;
            case 2:
                System.out.println("two");
                break;
            case 3:
                System.out.println("three");
                break;
            default:
                System.out.println("error");
                break;
        }
    }
}

Under normal circumstances, the user will enter a number between 1 and 3 according to the system prompts. However, if the user does not input as required, for example, enters a letter "a", an exception will occur when the program is run, and the running results are as follows.

請輸入您的選擇：（1~3 之間的整數(shù)）
a
Exception in thread "main" java.util.InputMismatchException
at java.util.Scanner.throwFor(Unknown Source)
at java.util.Scanner.next(Unknown Source)
at java.util.Scanner.nextInt(Unknown Source)
at java.util.Scanner.nextInt(Unknown Source)
at text.text.main(text.java:11)

Causes of exceptions and usage principles

There are three main reasons why an exception occurs in Java:

1. Java An internal error occurred, an exception generated by the Java virtual machine.

2. Exceptions caused by errors in the written program code, such as null pointer exceptions, array out-of-bounds exceptions, etc. This kind of exception is called an unchecked exception, and it is generally necessary to handle these exceptions centrally in certain classes.

3. Exceptions generated manually through the throw statement are called checked exceptions and are generally used to inform the caller of the method some necessary information.

Java handles exceptions through object-oriented methods. During the running of a method, if an exception occurs, the method will generate an object representing the exception and hand it to the runtime system. The runtime system will look for the corresponding code to handle the exception.

We call the process of generating an exception object and submitting it to the runtime system as throwing an exception. The runtime system searches the method's call stack until it finds an object that can handle that type of exception. This process is called catching the exception.

Java exceptions force users to consider the robustness and security of their programs. Exception handling should not be used to control the normal flow of the program. Its main function is to capture exceptions that occur when the program is running and handle them accordingly. When writing code to handle exceptions that may occur in a certain method, you can follow the following three principles:

1. Use the try catch statement in the current method declaration to catch exceptions.

2. When a method is overridden, the method that overrides it must throw the same exception or a subclass of the exception.

3. If the parent class throws multiple exceptions, the overriding method must throw a subset of those exceptions and cannot throw new exceptions.

Exception types

All exception types in Java are subclasses of the built-in class java.lang.Throwable class, that is, Throwable is located at the top level of the exception class hierarchy. There are two exception branches, Exception and Error, under the Throwable class, as shown in Figure 1.

As you can see from Figure 2, the Throwable class is the superclass of all exceptions and errors. There are two subclasses below: Error and Exception, which represent errors and exceptions respectively. Among them, the exception class Exception is divided into runtime exception and non-runtime exception. There is a big difference between these two exceptions, also called unchecked exception (Unchecked Exception) and checked exception (Checked Exception).

·Exception class is used for exceptions that may occur in user programs. It is also a class used to create custom exception type classes.

·Error defines exceptions that are not expected to be caught by the program under normal circumstances. Exceptions of type Error are used by the Java runtime to display errors related to the runtime system itself. Stack overflow is an example of this error.

·This chapter does not discuss exception handling of the Error type, because they are usually catastrophic and fatal errors that are beyond the control of the program. The remainder of this chapter discusses exception handling of the Exception type.

Runtime exceptions are exceptions of the RuntimeException class and its subclasses, such as NullPointerException, IndexOutOfBoundsException, etc. These exceptions are unchecked exceptions, and you can choose to capture them or not process them in the program. These exceptions are generally caused by program logic errors, and the program should try to avoid the occurrence of such exceptions from a logical perspective.

Non-runtime exceptions refer to exceptions other than RuntimeException, which belong to the Exception class and its subclasses. From the perspective of program syntax, it is an exception that must be handled. If it is not handled, the program will not be compiled. Such as IOException, ClassNotFoundException, etc. and user-defined Exception exceptions. Generally, no custom checked exceptions are used. Table 1 lists some common exception types and their functions.

php Chinese website, a large number of free Java introductory tutorials, welcome to learn online!

The above is the detailed content of what is exception in java. For more information, please follow other related articles on the PHP Chinese website!