概念

异常就是Java运行时出现的错误，异常是一个在程序执行期间发生的事件，它中断了正在执行的程序的正常指令流。

异常处理

捕捉异常

Java中异常捕捉的结构是由try、catch和final三个部分构成，try语句块中存放的是可能发生异常的java语句，catch程序块在try语句块之后，用来激发被捕获的异常；finally语句块是异常处理结构的最后执行部分，无论try语句块中的代码如何退出，都将执行finally语句块

  1. try{
  2.     //程序代码块
  3. }
  4. catch (Exceptiontype1 e){
  5.     //对Exceptiontype1的处理
  6. }
  7. catch (Exceptiontype2 e){
  8.      //对Exceptiontype2的处理 
  9. }
  10. ....
  11. finally{
  12.     //程序块
  13. }

完整的异常处理语句一定要包含finally语句，但是有四种特殊情况，finally语句块不会被执行：

  • 在finally语句块中发生了异常
  • 在前面的代码中使用了System.exit()退出程序
  • 程序所在的线程死亡
  • 关闭CPU

Java常见异常

在 Java 中，所有的异常都有一个共同的祖先java.lang包中的 Throwable类。Throwable： 有两个重要的子类：Exception（异常） 和 Error（错误） ，二者都是 Java 异常处理的重要子类，各自都包含大量子类。

Error（错误）:是程序无法处理的错误，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM（Java 虚拟机）出现的问题。例如，Java虚拟机运行错误（Virtual MachineError），当 JVM 不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时，如Java虚拟机运行错误（Virtual MachineError）、类定义错误（NoClassDefFoundError）等。这些错误是不可查的，因为它们在应用程序的控制和处理能力之 外，而且绝大多数是程序运行时不允许出现的状况。对于设计合理的应用程序来说，即使确实发生了错误，本质上也不应该试图去处理它所引起的异常状况。在 Java中，错误通过Error的子类描述。

Exception（异常）:是程序本身可以处理的异常。Exception类可根据错误发生的原因分为RuntimeException和非RuntimeException之外的异常，RuntimeException 异常由Java虚拟机抛出。NullPointerException（要访问的变量没有引用任何对象时，抛出该异常）、ArithmeticException（算术运算异常，一个整数除以0时，抛出该异常）和 ArrayIndexOutOfBoundsException （下标越界异常）。

注意：异常和错误的区别：异常能被程序本身可以处理，错误是无法处理。

Throwable类常用方法

  • public string getMessage():返回异常发生时的详细信息
  • public string toString():返回异常发生时的简要描述
  • public string getLocalizedMessage():返回异常对象的本地化信息。使用Throwable的子类覆盖这个方法，可以声称本地化信息。如果子类没有覆盖该方法，则该方法返回的信息与getMessage（）返回的结果相同
  • public void printStackTrace():在控制台上打印Throwable对象封装的异常信息

自定义异常

在程序中使用自定义异常类，通常有几个步骤。

  1. 创建自定义异常类。
  2. 在方法中通过throw关键字抛出异常对象。
  3. 如果在当前抛出异常的方法中处理异常，可以使用try-catch语句块捕获并处理，否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
  4. 在出现异常方法的调用者中捕获并处理异常。

  5. 此为自己定义的异常类 ``` public class MyException extends Exception{

    public MyException(String ErrorMessage){ super(ErrorMessage); }

}

  2. 6. 此为自己定义的普通类

//自定义异常 public class Tran { static int avg(int number1,int number2)throws MyException{ if(number1<0||number2<0){ throw new MyException("不可以使用负数"); } if (number1>100||number2>100){ throw new MyException(“数值太大了”); } return (number1+number2)/2; }

  1. public static void main(String[] args) {
  2.     try{
  3.         int result=avg(102,150);
  4.         System.out.println(result);
  5.     }catch (MyException e){
  6.         System.out.println(e);
  7.     }
  8. }

}

  2. <a name="z50dJ"></a>
  3. ## 在方法中抛出异常
  5. <a name="GBCGs"></a>
  6. ### 使用throws关键字抛出异常
  7. throws关键字通常被应用在声明方法的时候，用来指出方法中可能抛出的异常，多个异常之间用逗号隔开。

//在方法使用throws中抛出异常 public class Shoot { static void pop() throws NegativeArraySizeException{ int[] arr=new int[-3]; }

  1. public static void main(String[] args) {
  2.     try {
  3.         pop();
  4.     }catch (NegativeArraySizeException e){
  5.         System.out.println("pop抛出的异常");
  6.     }
  7. }

}

  2. <a name="rcBWw"></a>
  3. ### 使用throw关键字抛出异常
  4. throw关键字通常用于方法体中，并且抛出一个异常对象，程序在执行到throw语句时**立即终止**，后面的语句都不执行，通过throw抛出异常后，如果想在上一级代码中来捕获并处理异常，则需要在抛出异常的方法中使用throws关键字在方法的声明中指明要抛出的异常，如果要捕获throw抛出的异常，则必须用try-catch语句块
  6. - 自己定义的异常类MyException，继承与Exception。

//此为自己定义的异常类MyException,继承与Exception public class MyException extends Exception{ String message; public MyException(String ErrorMessage){ message=ErrorMessage; } public String getMessage(){ return message; } }

  2. - 测试类

//使用throw关键字抛出异常 public class Captor { static int quotient(int x,int y)throws MyException{ if (y<0){ throw new MyException(“除数不能为负”); } return x/y; }

  1. public static void main(String[] args) {
  2.     try{
  3.         int result=quotient(3,-1);
  4.     }catch (MyException e){
  5.         System.out.println(e.getMessage());
  6.     }catch (ArithmeticException e){
  7.         System.out.println("除数不能为0");
  8.     }catch (Exception e){
  9.         System.out.println("程序出现了其他方面的异常");
  10.     }
  11. }

} ```