异常java讲解

异常在编程中起到了重要的作用，主要体现在以下几个方面：

1. 错误处理：异常机制提供了一种优雅、可控的方式来处理程序中可能发生的错误情况。通过捕获和处理异常，程序可以在错误发生时采取相应的措施，例如输出错误信息、进行恢复操作或终止程序的执行。

2. 异常传递：当一个方法出现异常时，它可以通过抛出异常的方式将错误信息传递给调用该方法的地方。这样，异常可以在方法的调用链中被捕获和处理，使得错误处理的责任可以由调用方来承担。

3. 代码结构清晰：使用异常机制可以将错误处理代码与正常的业务代码分离开来，使得程序的逻辑更加清晰易懂。异常处理可以放在专门的 catch 块中，不会干扰正常的代码流程，提高了代码的可读性和可维护性。

4. 异常信息追踪：当异常发生时，异常机制会生成一个异常对象，并包含有关异常发生位置、错误原因等详细信息。这些信息可以帮助程序员快速定位和诊断问题，提高调试效率。

5. 异常类的扩展性：在Java中，我们可以自定义异常类，以便根据具体的业务需求来处理特定类型的异常。通过继承自现有的异常类，我们可以创建更具体、更符合实际场景的异常类型，提高程序的可维护性和可扩展性。

异常处理是指在程序中捕获和处理可能发生的异常情况的过程 

异常的常用方法

1. getMessage()：获取异常的错误消息。

2. toString()：返回异常的字符串表示，包括异常类的名称和错误消息。

3. printStackTrace()：将异常的跟踪栈信息输出到标准错误流（通常是控制台）。

4. getCause()：获取导致当前异常的原因异常，如果没有原因异常，则返回 null。

public class ExceptionMethodsExample {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0);
            System.out.println("结果：" + result);
        } catch (ArithmeticException e) {
            System.out.println("发生异常：" + e.getMessage());
            System.out.println("异常信息：" + e.toString());
            e.printStackTrace();
            System.out.println("原因异常：" + e.getCause());
        }
    }

    public static int divide(int a, int b) {
        return a / b;
    }
}

在上述代码中，我们定义了一个 divide 方法，用于执行除法操作。在 main 方法中，我们调用 divide 方法并捕获 ArithmeticException 异常。然后，我们使用异常提供的方法输出异常信息。

可以注意到，我们在捕获异常后依次调用了 getMessage()、toString()、printStackTrace() 和 getCause() 方法。这些方法为我们提供了关于异常的详细信息，例如错误消息、异常字符串表示、跟踪栈信息和原因异常。

捕获异常

捕获异常是指在程序中使用 try-catch 块来捕获可能引发的异常。通过捕获异常，我们可以在异常发生时执行特定的代码逻辑，并进行相应的处理操作。以下是捕获异常的基本语法：

try {
    // 可能抛出异常的代码
} catch (ExceptionType1 e1) {
    // 处理 ExceptionType1 类型的异常
} catch (ExceptionType2 e2) {
    // 处理 ExceptionType2 类型的异常
} finally {
    // 不论是否发生异常，都会执行的代码（可选）
}

在 try 块中，我们编写可能会引发异常的代码。如果在执行该代码时发生了异常，程序会立即跳转到相应 catch 块的代码处，根据异常类型匹配执行对应块中的代码。

在 catch 块中，我们可以编写处理异常的代码逻辑。可以根据不同的异常类型选择不同的处理方式，例如输出错误信息、记录日志、进行恢复操作等。一个 try 块可以包含多个 catch 块来处理不同类型的异常，按照 catch 块的先后顺序进行匹配。

在 finally 块中，我们可以编写一些无论是否发生异常都需要执行的代码，例如释放资源、关闭连接等。finally 块中的代码不论是否发生异常都会被执行。

try {
    int result = divide(10, 0);
    System.out.println("结果：" + result);
} catch (ArithmeticException e) {
    System.out.println("发生了算术异常：" + e.getMessage());
} catch (Exception e) {
    System.out.println("发生了其他异常：" + e.getMessage());
} finally {
    System.out.println("无论是否发生异常，都会执行的代码");
}

private static int divide(int a, int b) {
    return a / b;
}

在上述代码中，我们调用 divide 方法进行除法运算。由于除数为 0，会抛出 ArithmeticException 异常，在 catch 块中捕获该异常并输出相应的错误信息。无论是否发生异常，finally 块中的代码都会被执行，输出对应的提示信息。

如果在 try 块中发生异常，并且没有在 try-catch 结构中进行捕获处理，那么异常将会被传递到调用者处继续处理。具体的处理方式取决于异常的类型和相应的上层调用栈。

当异常未被捕获时，会发生以下两种情况之一：

1. 如果异常是 checked 异常（即需要在方法签名中声明或捕获的异常），则调用者方法必须进行异常处理。否则，编译器将报告错误并要求处理该异常。调用者可以选择在其方法签名中声明该异常或使用 try-catch 块来捕获和处理异常。

2. 如果异常是 unchecked 异常（即 RuntimeException 及其子类），则调用者可以选择捕获并处理异常，或者让异常传递到更高层级的调用栈。如果异常一直传递到最高层级的调用者，但仍然没有被捕获处理，将导致程序终止并输出异常信息。

自定义异常

 在 Java 中，我们可以通过创建自定义异常类来满足特定的业务需求。自定义异常类继承自现有的异常类（通常是 Exception 或其子类），并添加额外的属性和行为。

public class CustomExceptionExample {
    public static void main(String[] args) {
        try {
            withdrawMoney(1000, 500);
        } catch (InsufficientBalanceException e) {
            System.out.println(e.getMessage());
        }
    }

    public static void withdrawMoney(int balance, int amount) throws InsufficientBalanceException {
        if (amount > balance) {
            throw new InsufficientBalanceException("余额不足");
        } else {
            balance -= amount;
            System.out.println("成功取款 " + amount + " 元");
        }
    }
}

class InsufficientBalanceException extends Exception {
    public InsufficientBalanceException(String message) {
        super(message);
    }
}

在上述代码中，我们定义了一个 withdrawMoney 方法，用于从银行账户中取款。如果账户余额小于取款金额，我们就抛出一个自定义的 InsufficientBalanceException 异常，并传递相应的错误消息。

在 main 方法中，我们调用 withdrawMoney 方法并使用 try-catch 块捕获异常。如果余额不足，将抛出异常对象并在 catch 块中进行处理，输出错误消息。

自定义异常类 InsufficientBalanceException 继承自 Exception 类，并提供了一个带有错误消息的构造函数。通过自定义异常类，我们可以更好地描述和处理特定的异常情况，使代码更加可读和可维护。

抛出异常

在 Java 中，我们可以使用 throw 关键字来抛出自定义的异常或者已有的异常。通过抛出异常，我们可以在程序中明确指示出现了错误或异常情况，并将控制权传递给调用方进行处理。

要抛出异常，可以按照以下步骤进行操作：

1. 创建一个异常对象：使用合适的异常类（可以是 Java 标准库中的异常类，也可以自定义异常类）创建一个异常对象。可以使用 new 关键字和相应的构造函数来实例化异常对象。

2. 抛出异常对象：使用 throw 关键字将异常对象抛出。抛出异常后，程序立即转移到最近的异常处理代码（包括 try-catch 块或方法签名中声明的 throws 子句）。

   public class CustomExceptionExample {
       public static void main(String[] args) {
           try {
               validateAge(15);
           } catch (InvalidAgeException e) {
               System.out.println(e.getMessage());
           }
       }
   
       public static void validateAge(int age) throws InvalidAgeException {
           if (age < 18) {
               throw new InvalidAgeException("年龄必须大于等于18岁");
           } else {
               System.out.println("年龄验证通过");
           }
       }
   }
   
   class InvalidAgeException extends Exception {
       public InvalidAgeException(String message) {
           super(message);
       }
   }
   

   在上述代码中，我们定义了一个 validateAge 方法，用于验证年龄是否大于等于 18 岁。如果年龄小于 18，我们就抛出一个自定义的 InvalidAgeException 异常，并传递相应的错误消息。

   在 main 方法中，我们调用 validateAge 方法并使用 try-catch 块捕获异常。如果年龄不符合要求，将抛出异常对象并在 catch 块中进行处理，输出错误消息。

   注意，当方法可能抛出已检查的异常时，需要在方法的签名中使用 throws 关键字声明异常。在上述示例代码中，我们在 validateAge 方法的签名中添加了 throws InvalidAgeException，表明该方法可能抛出 InvalidAgeException 异常。