How to catch and handle java exceptions

Java exception capture and processing methods: 1. throws keyword, the system automatically throws the captured exception information to the superior calling method; 2. The function of throw is to manually throw the instantiation object of the exception class ;3. RunException is a subclass of Exception, and it is up to the user to choose whether to process it.

[Related learning recommendations: java basic tutorial]

Java exception catching and handling methods:

1. The use of exception handling

Since the finally block can be omitted, the exception handling format can be divided into three categories: try{}——catch { }, try{ }——catch{ }——finally{ }, try{ }——finally{ }.

 1 public class DealException
 2 {
 3     public static void main(String args[])
 4     {    
 5         try
 6         //要检查的程序语句
 7         {
 8             int a[] = new int[5];
 9             a[10] = 7;//出现异常
10         }
11         catch(ArrayIndexOutOfBoundsException ex)
12         //异常发生时的处理语句
13         {
14             System.out.println("超出数组范围！");
15         }
16         finally
17         //这个代码块一定会被执行
18         {
19             System.out.println("*****");
20         }
21         System.out.println("异常处理结束！");
22     }
23 }

It can be seen that two judgments must be made during the exception catching process. The first is whether an exception is generated in the try program block, and the second is whether the generated exception is consistent with the one you want to catch in the catch() brackets. The exception is the same.

So, what should you do if the exception that occurs is different from the exception you want to catch in catch()? In fact, we can follow a try statement with multiple exception handling catch statements to handle many different types of exceptions.

 1 public class DealException
 2 {
 3     public static void main(String args[])
 4     {    
 5         try
 6         //要检查的程序语句
 7         {
 8             int a[] = new int[5];
 9             a[0] = 3;
10             a[1] = 1;
11             //a[1] = 0;//除数为0异常
12             //a[10] = 7;//数组下标越界异常
13             int result = a[0]/a[1];
14             System.out.println(result);
15         }
16         catch(ArrayIndexOutOfBoundsException ex)
17         //异常发生时的处理语句
18         {
19             System.out.println("数组越界异常");
20             ex.printStackTrace();//显示异常的堆栈跟踪信息
21         }
22         catch(ArithmeticException ex)
23         {
24             System.out.println("算术运算异常");
25             ex.printStackTrace();
26         }
27         finally
28         //这个代码块一定会被执行
29         {
30             System.out.println("finally语句不论是否有异常都会被执行。");
31         }
32         System.out.println("异常处理结束！");
33     }
34 }

In the above example, ex.printStackTrace(); is the use of the exception class object ex, which outputs detailed exception stack trace information, including the type of exception, which package, which class, and which method the exception occurred in. and the line number where the exception occurred.

2. The throws keyword

The method declared by throws means that the method does not handle exceptions, but the system automatically throws the captured exception information to the superior calling method.

 1 public class throwsDemo
 2 {
 3     public static void main(String[] args) 
 4     {
 5         int[] a = new int[5];
 6         try
 7         {
 8             setZero(a,10);
 9         }
10         catch(ArrayIndexOutOfBoundsException ex)
11         {
12             System.out.println("数组越界错误！");
13             System.out.println("异常："+ex);
14         }
15         System.out.println("main()方法结束。");
16     }
17     private static void setZero(int[] a,int index) throws ArrayIndexOutOfBoundsException
18     {
19         a[index] = 0;
20     }
21 }

The throws keyword throws an exception. "ArrayIndexOutOfBoundsException" indicates the type of exception that may exist in the setZero() method. Once an exception occurs in the method, the setZero() method does not handle it itself, but submits the exception to it. The superior caller main() method.

3. Throw keyword

The function of throw is to manually throw the instantiated object of the exception class.

 1 public class throwDemo
 2 {
 3     public static void main(String[] args) 
 4     {
 5         try
 6         {
 7             //抛出异常的实例化对象
 8             throw new ArrayIndexOutOfBoundsException("\n个性化异常信息：\n数组下标越界");
 9         }
10         catch(ArrayIndexOutOfBoundsException ex)
11         {
12             System.out.println(ex);
13         }
14     }
15 }

We can find that throw seems to be looking for trouble, causing runtime exceptions and customizing prompt information. In fact, throw is usually used in conjunction with throws, and what is thrown is an instance of the exception class that has been generated in the program.

ExceptionDemo

Output result:

setZero method starts:

setZero method ends.

Exception: java.lang.ArrayIndexOutOfBoundsException: 10

main() method ends!

4. RuntimeException class

The difference between Exception and RuntimeException:

Exception: It is mandatory for users to handle it;

RunException : is a subclass of Exception, and it is up to the user to choose whether to handle it.

The custom exception class inherits from the Exception class and can be used There are a lot of methods in the parent class, and you can also write your own methods to handle specific events. Java provides an inheritance method to run exception classes written by users.

 1 class MyException extends Exception
 2 {
 3     public MyException(String message)
 4     {
 5         super(message);
 6     }
 7 }
 8 public class DefinedException
 9 {
10     public static void main(String[] args) 
11     {
12         try
13         {
14             throw new MyException("\n自定义异常类！");
15         }
16         catch(MyException e)
17         {
18             System.out.println(e);
19         }
20     }
21 }