Java的异常处理机制是一种强大的错误处理工具，它允许开发者在运行时捕获和处理异常情况。这种机制主要通过try, catch, finally, 和 throw 关键字来实现。

异常处理流程

1. 抛出异常（Throwing an Exception）

   • 当程序遇到无法处理的错误时，它会创建一个异常对象并“抛出”该对象。这可以通过使用 throw 关键字来完成。

   • 开发者也可以在代码中显式地抛出异常，以指示某个方法不能继续执行。

2. 捕获异常（Catching an Exception）

   • 使用 try 块来包围可能会抛出异常的代码。

   • 使用 catch 块来捕获并处理 try 块中抛出的异常。可以有多个 catch 块来捕获不同类型的异常。

3. 最终处理（Finally Block）

   • finally 块包含的代码无论是否发生异常都会执行。这通常用于释放资源（如关闭文件或数据库连接）或其他清理工作。

4. 异常传播（Exception Propagation）

   • 如果在 try 或 catch 块中不处理异常，异常会继续向上传播，直到被更上层的代码捕获或导致程序终止。

异常类

Java中的异常类都是 java.lang.Throwable 类的子类。Throwable 有两个主要的子类：java.lang.Error 和 java.lang.Exception。

• Error：表示严重的问题，通常是由JVM或系统环境引起的，如OutOfMemoryError。这些错误是不可恢复的，通常不需要（也不应该）由应用程序代码来处理。

• Exception：表示程序本身可以处理的问题，如逻辑错误或输入错误。这些异常可以被捕获并处理，以防止程序崩溃或提供用户友好的错误消息。

自定义异常

在Java中，自定义异常是通过创建一个新的类来实现的，这个新类通常继承自Exception类或其子类。自定义异常类允许你定义特定于应用程序的错误情况，并提供有关错误原因的详细信息。下面是一个简单的示例，展示了如何创建和使用自定义异常类：

首先，创建一个自定义异常类，继承自Exception类：

public class CustomException extends Exception {    
    public CustomException(String message) {        
        super(message);    
    }    
    // 可以添加其他构造函数或方法
}

在这个例子中，CustomException类只有一个构造函数，它接受一个字符串参数message，这个参数将用作异常的描述信息。

然后，你可以在你的代码中抛出这个自定义异常：

public class CustomExceptionExample {    
    public static void main(String[] args) {
        try {            
            // 调用可能抛出自定义异常的方法
            methodThatThrowsCustomException();        
        } catch (CustomException e) {            
            // 处理自定义异常           
            System.out.println("捕获到自定义异常: " + e.getMessage());        
        }    
    }    
    public static void methodThatThrowsCustomException() throws CustomException {        
        // 在某些条件下抛出自定义异常        
        if (true) { 
            // 这里是一个示例条件，实际中会是某些业务逻辑判断            
            throw new CustomException("这是一个自定义异常");        
        }        // 其他代码...    
    }
}

在这个例子中，methodThatThrowsCustomException方法在满足某个条件时抛出了CustomException。在main方法中，我们使用try-catch块来捕获并处理这个自定义异常。

当methodThatThrowsCustomException方法抛出CustomException时，控制权将转移到catch块，其中打印出异常的描述信息。

自定义异常类可以包含更多的逻辑，比如添加额外的字段来存储关于异常的更多信息，或者定义额外的方法来进行错误处理等。这样做可以使异常处理更加灵活和强大。

请注意，如果自定义异常类继承自RuntimeException或其子类，那么它将成为一个未检查的异常，这意味着在调用它的方法时不需要显式地处理这个异常（即不需要在方法签名中使用throws关键字或在方法内部使用try-catch块）。然而，对于自定义异常，通常更推荐的做法是使其成为一个受检查的异常，这样可以让调用者更加明确地知道可能存在的错误情况，并相应地处理它们。

异常链（Exception Chaining）

Java允许通过构造异常对象时传递一个“cause”异常来创建异常链。这有助于追踪异常的根源。

异常规范（Exception Specification）

方法可以使用 throws 关键字来声明它可能抛出的异常类型。这称为方法的异常规范。调用该方法的代码必须处理或声明这些异常。

示例

public class ExceptionExample {    
    public static void main(String[] args) {        
        try {            
            int result = divide(10, 0); // 这将抛出一个ArithmeticException       
        } catch (ArithmeticException e) {            
            System.out.println("捕获到异常: " + e.getMessage());
            e.printStackTrace(); //打印错误的栈信息
        } finally {            
            System.out.println("最终块执行了");       
        }    
    }    
    
    public static int divide(int a, int b) throws ArithmeticException {       
        if (b == 0) {
            throw new ArithmeticException("除数不能为0");       
        }
        return a / b;    
    }
}

在这个示例中，divide 方法可能会抛出一个 ArithmeticException，因此在方法签名中使用了 throws 关键字。在 main 方法中，我们尝试调用 divide 方法并捕获可能抛出的异常。无论是否抛出异常，finally 块中的代码都会被执行。

throw关键字

throw关键字用于显式地抛出一个异常。当你使用throw关键字时，你正在创建一个新的异常对象并立即将其抛出。这通常发生在检测到一个错误条件时，例如，当方法不能继续执行其预期任务时。

下面是使用throw关键字的一个简单示例：

public class Example {    
    public static void main(String[] args) {        
        try {            
            checkAge(12);        
        } catch (IllegalArgumentException e){            
            System.out.println("捕获到异常: " + e.getMessage());        
        }    
    }    
    public static void checkAge(int age) throws IllegalArgumentException {        
        if (age < 18) {            
            throw new IllegalArgumentException("年龄必须大于或等于18");        
        }        
        System.out.println("年龄验证通过");    
    }
}

在这个例子中，checkAge方法检查年龄是否小于18。如果是，它使用throw关键字抛出一个IllegalArgumentException。在main方法中，我们使用try-catch块来捕获并处理这个异常。

throws关键字

throws关键字用于声明一个方法可能抛出的异常类型。它告诉方法的调用者，该方法可能会抛出一种或多种异常，因此调用者需要处理这些异常（使用try-catch块）或将其继续向上抛出（通过在方法签名中使用throws关键字）。

下面是使用throws关键字的一个简单示例：

public class Example {    
    public static void main(String[] args) {        
        try {            
            riskyOperation();        
        } catch (Exception e) {            
            System.out.println("捕获到异常: " + e.getMessage());        
        }    
    }    
    public static void riskyOperation() throws Exception {        //这里可以抛出任何类型的Exception或其子类
        throw new IOException("这是一个IO异常");    
    }
}

在这个例子中，riskyOperation方法声明它可能会抛出任何类型的Exception或其子类。因此，调用riskyOperation的main方法必须处理Exception，即使实际抛出的异常可能是Exception的一个特定类型（如IOException）。

区别

• throw用于实际抛出异常对象。

• throws用于声明方法可能抛出的异常类型，以便调用者知道需要处理这些异常。

使用规则

• 如果一个方法内部使用throw抛出了异常，那么该方法的调用者必须处理这个异常（使用try-catch块）或声明它也可能抛出这个异常（使用throws关键字）。

• 如果一个方法没有使用throw关键字抛出异常，但它的方法签名中使用了throws关键字声明了可能抛出的异常，那么这个方法本身不需要处理这些异常，但调用者必须处理它们。

总结

Java的异常处理机制为开发者提供了一个强大的工具来管理程序运行时的错误情况。通过正确地使用 try, catch, finally, 和 throw 关键字，以及创建自定义异常类，开发者可以编写更加健壮和可维护的代码。

try-catch快捷键：ctrl + alt + t