How does java throw an exception

If you want to throw an exception in Java, you need to use two keywords of Java, both of which are used for exception handling mechanisms.

A method does not handle this exception, but passes it up the calling hierarchy. Whoever calls this method will handle this exception. This is what throws an exception.

throw: Throw the generated exception (the emphasis is on the action). What is thrown can be either an exception reference or an exception object. (Location: inside the method body)

throws: If a method may throw an exception, but does not have the ability to handle this exception, you can use the throws clause at the method declaration to declare that an exception is thrown. . The method modified with it indicates to the caller that the method may throw an exception (it can be one type or multiple types, separated by commas) (position: written after the method name or method name list, in the method Before the body.)

Note: When calling a method that may throw an exception, you must add a try-catch code block to try to catch the exception or add a throws statement to throw the exception to the upper level. A layer of callers handles it. One detail needs to be noted here: the new exception contains all the information of the original exception. Based on this, we can trace the location where the original exception occurred.

Simple use:

// 定义一个方法,抛出 数组越界和算术异常（多个异常 用 "," 隔开）
public void Test1(int x) throws ArrayIndexOutOfBoundsException,ArithmeticException{
	System.out.println(x);
	if(x == 0){
		System.out.println("没有异常");
		return;
	}
	//数据越界异常
	else if (x == 1){
		int[] a = new int[3];
		a[3] = 5;
	}
	//算术异常
	else if (x == 2){
		int i = 0;
		int j = 5/0;
	}
}

Call in main method:

public static void main(String[] args) {
        //创建对象
        ExceptionInital object = new ExceptionInital();
        // 调用会抛出异常的方法，用try-catch块
        try{
            object.Test1(0);
        }catch(Exception e){
            System.out.println(e);
        }
        // 数组越界异常
        try{
            object.Test1(1);
        }catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("数组越界异常:"+e);
        }

        // 算术异常
        try{
            object.Test1(2);
        }catch(ArithmeticException e){
            System.out.println("算术异常:"+e);
        }

        //使用 throw 抛出异常(可以抛出异常对象，也可以抛出异常对象的引用)
        try{
            ArrayIndexOutOfBoundsException  exception = new ArrayIndexOutOfBoundsException();
            throw exception;//new ArrayIndexOutOfBoundsException();
        }catch(ArrayIndexOutOfBoundsException e){
            System.out.println("thorw抛出异常:"+e);
        }
    }

Run result:

Summarize the difference between throw and throws keywords

1. Writing method: throw is used in the method body, throws is used after the function name or after the parameter list and before the method body

2. Meaning: throw emphasizes action, while throws indicates a tendency, which may but not necessarily actually occur

3. Throws is followed by the exception class, which can be one or more. Multiples are separated by commas. . throw is followed by the exception object, or a reference to the exception object.

4. throws The user throws an exception. When the exception is thrown in the current method, the execution of the current method ends (after throws, if there is a finally statement, it will be executed until the finally statement and then end.). It can be understood as return.

Related learning recommendations: java basic tutorial

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