文章中的部分照片来源于哔站黑马程序员阿伟老师处，仅用学习，无商用，侵权联系删除！

具体异常信息请查看 API 帮助文档

1. 概述

在Java中，错误（Error）类和异常（Exception）类都是继承自Throwable类，用于表示程序中出现的问题或异常情况。

• 错误类（Error）：错误类表示严重的问题，通常是由虚拟机内部错误或系统资源耗尽等问题引起的。这些错误类通常是无法恢复的，程序无法处理，也没有必要进行捕获和处理。

  • 需要注意的是，错误类通常由虚拟机自动抛出，而不需要代码中显式地进行捕获和处理。

• 异常类（Exception）：异常类用于表示程序中的正常但意外的情况。与错误类不同，异常类分为两类：编译异常和运行异常。

  • 编译异常（Checked Exception）：编译异常指在编译阶段就需要处理的异常，编译器会强制要求程序员在代码中显式地捕获和处理这些异常。

    • 处理编译异常的方式可以是使用try-catch块捕获和处理异常，或者在方法中使用throws关键字声明可能抛出的受检异常。

  • 运行异常（Unchecked Exception）：运行异常是在程序执行过程中发生的异常，不需要在代码中显式地捕获和处理。它们通常由代码中的错误或逻辑问题引起，如空指针异常（NullPointerException）或数组索引越界异常（ArrayIndexOutOfBoundsException）等。

    • 运行异常通常表示程序的逻辑错误或程序员的错误。
    • 处理运行异常的方式是可选择性地进行捕获和处理，也可以让程序崩溃并终止运行。

  • 需要注意的是，RuntimeException及其子类是Java中常见的运行异常类。

除了预定义的错误类和异常类，Java还允许使用者自定义异常类。通过继承Exception类或其子类来创建自定义异常类，以更好地描述和处理特定的异常情况。

2. Throwable 方法

2.1 概述

• Throwable 是 Java 中所有错误和异常的根类。它定义了处理错误和异常的基本方法和属性。

• 需要注意的是，Throwable 是一个抽象类，不能直接实例化。

• 它有两个直接子类：Error 和 Exception。

  • Error 类表示严重的错误，通常无法恢复；

  • Exception 类表示可处理的异常情况。

  • 开发者也可以继承 Throwable 类创建自定义的错误或异常类。

• Throwable的成员方法：

  方法名称	说明
  public string getMessage()	返回此 throwable 的详细消息字符串
  public string toString()	返回此可抛出的简短描述
  public void printStackTrace()	用红色字体把异常的错误信息输出在控制台（仅仅是打印信息，不会停止虚拟机）

• 正确的输出语句：System.out.println();

• 错误的输出语句：（不是代码错误，而是用来打印错误信息的）System.err.println();

   细节：当正确的输出语句和错误的输出语句同时使用时，两者的输出顺序不确定。
  

2.2 代码示例

• 代码示例

  package text.text02;/*
  Throwable的成员方法：| 方法名称                      | 说明                                                         |
  | ----------------------------- | ------------------------------------------------------------ |
  | public string getMessage()    | 返回此 throwable 的详细消息字符串                            |
  | public string tostring()      | 返回此可抛出的简短描述                                       |
  | public void printstackTrace() | 用红色字体把异常的错误信息输出在控制台（仅仅是打印信息，不会停止虚拟机） |正确的输出语句：System.out.println();
  错误的输出语句：（不是代码错误，而是用来打印错误信息的）System.err.println();细节：当正确的输出语句和错误的输出语句同时使用时，两者的输出顺序不确定。*/
  public class text88 {public static void main(String[] args) {int[] arr = {1, 2, 3, 4, 5, 6, 7, 8};//1.public string getMessage(): 返回此 throwable 的详细消息字符串System.out.println("=============== 1.public string getMessage(): 返回此 throwable 的详细消息字符串 ===============");//自己处理（捕获异常）try {System.out.println(arr[10]);//索引越界异常 ArrayIndexOutOfBoundsException} catch (ArrayIndexOutOfBoundsException e) {String message = e.getMessage();System.out.println(message);}//检验代码是否执行到这一步System.out.println("try...catch体系外的代码执行了");//2.public string tostring(): 返回此可抛出的简短描述System.out.println("=============== 2.public string tostring(): 返回此可抛出的简短描述 ===============");//自己处理（捕获异常）try {System.out.println(arr[10]);//索引越界异常 ArrayIndexOutOfBoundsException} catch (ArrayIndexOutOfBoundsException e) {String str = e.toString();System.out.println(str);}//检验代码是否执行到这一步System.out.println("try...catch体系外的代码执行了");//3.public void printstackTrace(): 用红色字体把异常的错误信息输出在控制台（仅仅是打印信息，不会停止虚拟机）System.out.println("=============== 3.public void printstackTrace(): 用红色字体把异常的错误信息输出在控制台（仅仅是打印信息，不会停止虚拟机） ===============");//自己处理（捕获异常）try {System.out.println(arr[10]);//索引越界异常 ArrayIndexOutOfBoundsException} catch (ArrayIndexOutOfBoundsException e) {e.printStackTrace();}//检验代码是否执行到这一步System.out.println("try...catch体系外的代码执行了");}
  }

• 输出结果
  

3. 异常分类

我们平常说的异常就是指Exception，因为这类异常一旦出现，我们就要对代码进行更正，修复程序。

异常(Exception)的分类:根据在编译时期还是运行时期去检查异常

• 编译时期异常:checked异常。在编译时期,就会检查,如果没有处理异常,则编译失败。(如日期格式化异常)

• 运行时期异常:runtime异常。在运行时期,检查异常.在编译时期,运行异常不会编译器检测(不报错)。(如数学异常)

​

4. 异常处理方式

4.1 JVM默认处理异常

JVM（Java虚拟机）具有默认的异常处理机制，用于处理在程序执行期间可能抛出的未捕获异常。

• JVM默认处理异常的方式：

  1. 把异常的名称，异常原因及异常出现的位置等信息输出在了控制台

  2. 程序停止执行，异常下面的代码就不会再执行

需要注意的是，JVM的默认异常处理机制只能处理未捕获的异常。对于已经在代码中进行了捕获并做了处理的异常，JVM不会介入其中。

• 代码示例

  package text.text02;/*
  JVM默认处理异常的方式：1.把异常的名称，异常原因及异常出现的位置等信息输出在了控制台2.程序停止执行，异常下面的代码就不会再执行*/
  public class text82 {public static void main(String[] args) {System.out.println("aaaaa");System.out.println("bbbbb");//算术异常(ArithmeticException)System.out.println(10 / 0);System.out.println("ccccc");System.out.println("ddddd");}
  }

• 输出结果
  

4.2 自己处理（捕获异常）try...catch

4.2.1 概述

• 目的：当代码出现异常时，可以让程序继续往下执行。

• 在Java中，可以使用try...catch语句块来捕获和处理异常。

• try...catch语句块的基本语法如下：

  try {// 可能会抛出异常的代码
  } catch (异常类型1 异常变量1) {// 处理异常类型1的代码
  } catch (异常类型2 异常变量2) {// 处理异常类型2的代码
  } finally {// 可选的finally代码块，无论是否发生异常，都会被执行
  }
  

try代码块包含了可能会抛出异常的代码。当异常发生时，Java虚拟机会立即停止当前代码块的执行，并跳转到catch代码块中，根据异常的类型与catch代码块中的异常类型进行匹配。

• 如果匹配成功，则执行对应的catch代码块，进行异常处理。

• 如果没有匹配的catch代码块，则异常将被传递到更高层的调用栈中，继续寻找匹配的catch代码块。

• 如果找不到任何匹配的catch代码块，程序将会终止，并输出相关的异常信息。

catch代码块用于处理特定类型的异常。你可以在一个try结构中使用多个catch代码块，以处理不同类型的异常。每个catch代码块包含了异常类型和异常变量，异常变量用于引用被捕获的异常对象，以便进行进一步的处理。

finally代码块是可选的，用于定义无论是否发生异常，都会执行的代码。它一般被用于释放资源或进行清理操作。即使在try或catch代码块中有return语句，finally代码块仍然会在return之前执行。

• 代码示例

  package text.text02;/*自己处理（捕获异常）
  格式：try {可能出现的异常;} catch (异常类名 变量名){异常的处理代码;}目的：当代码出现异常时，可以让程序继续往下执行。自己处理（捕获异常）灵魂四问：1.一问：如果try中没有遇见问题，怎么执行？答：如果try中没有遇见问题，会吧try里面的代码全部执行完毕，再继续执行try...catch体系下面的其他代码，而不会执行catch里面的代码注意：只有当出现了异常才会执行catch里面的代码。2.二问：如果try中可能遇见多个问题，怎么执行？答：如果try中可能遇见多个问题，一般需要写多个catch与之对应。try中代码会从上往下执行，如果try中有异常没有与catch对应，则会默认采取JVM默认处理异常的方式（1.把异常的名称，异常原因及异常出现的位置等信息输出在了控制台 2.程序停止执行，异常下面的代码就不会再执行）细节：如果我们要捕获多个异常，这些异常中如果存在父子关系的话，那么父类一定要写在下面JDK7之后，可以在catch中同时捕获多个异常，中间用 | 隔开，表示如果出现了A异常或者B异常时，采用同一种处理方案3.三问：如果try中遇见的问题没有被捕获，怎么执行？答：如果try中遇见的问题没有被捕获,相当于try...catch体系白写了，Java会默认采取JVM默认处理异常的方式（1.把异常的名称，异常原因及异常出现的位置等信息输出在了控制台 2.程序停止执行，异常下面的代码就不会再执行）4.四问：如果try中遇见了问题，那么try下面的其他代码还会执行吗？答：如果try中遇见了问题，那么try下面的其他代码不会执行了，会直接跳转到catch当中，执行catch里面的代码。如果try中有异常没有与catch对应，则会默认采取JVM默认处理异常的方式（1.把异常的名称，异常原因及异常出现的位置等信息输出在了控制台 2.程序停止执行，异常下面的代码就不会再执行）*/
  public class text83 {public static void main(String[] args) {int[] arr = {1, 2, 3, 4, 5, 6, 7, 8};//自己处理（捕获异常）try {System.out.println(arr[10]);//索引越界异常 ArrayIndexOutOfBoundsException//此处出现了异常，程序就会在这里创建一个ArrayIndexOutOfBoundsException（索引越界异常）对象（new ArrayIndexOutOfBoundsException()）；拿着这个对象到catch的小括号中对比，看括号中的变量是否可以接受这个对象。如果可以被接受，就表示该异常被捕获（抓住），执行catch里面对应的代码。当catch里面的所有的代码都执行完毕，继续执行try...catch体系下面的其他代码//异常类名: ArrayIndexOutOfBoundsException//变量名: e} catch (ArrayIndexOutOfBoundsException e) {System.out.println("索引越界异常!" + e);}//检验代码是否执行到这一步System.out.println("try...catch体系外的代码执行了");}
  }

• 输出结果
  

4.2.2 灵魂四问

自己处理（捕获异常）灵魂四问：

1. 一问：如果try中没有遇见问题，怎么执行？

   • 答：如果try中没有遇见问题，会吧try里面的代码全部执行完毕，再继续执行try…catch体系下面的其他代码，而不会执行catch里面的代码

   • 注意：只有当出现了异常才会执行catch里面的代码。

2. 二问：如果try中可能遇见多个问题，怎么执行？

   • 答：如果try中可能遇见多个问题，一般需要写多个catch与之对应。

   • try中代码会从上往下执行，如果try中有异常没有与catch对应，则会默认采取JVM默认处理异常的方式（1.把异常的名称，异常原因及异常出现的位置等信息输出在了控制台 2.程序停止执行，异常下面的代码就不会再执行）

   • 细节：如果我们要捕获多个异常，这些异常中如果存在父子关系的话，那么父类一定要写在下面

   • JDK7之后，可以在catch中同时捕获多个异常，中间用 | 隔开，表示如果出现了A异常或者B异常时，采用同一种处理方案

3. 三问：如果try中遇见的问题没有被捕获，怎么执行？

   • 答：如果try中遇见的问题没有被捕获,相当于try…catch体系白写了，Java会默认采取JVM默认处理异常的方式（1.把异常的名称，异常原因及异常出现的位置等信息输出在了控制台 2.程序停止执行，异常下面的代码就不会再执行）

4. 四问：如果try中遇见了问题，那么try下面的其他代码还会执行吗？

   • 答：如果try中遇见了问题，那么try下面的其他代码不会执行了，会直接跳转到catch当中，执行catch里面的代码。如果try中有异常没有与catch对应，则会默认采取JVM默认处理异常的方式（1.把异常的名称，异常原因及异常出现的位置等信息输出在了控制台 2.程序停止执行，异常下面的代码就不会再执行）

• 代码示例1：一问：如果try中没有遇见问题，怎么执行？

  package text.text02;/*自己处理（捕获异常）灵魂四问：一问：如果try中没有遇见问题，怎么执行？答：如果try中没有遇见问题，会吧try里面的代码全部执行完毕，再继续执行try...catch体系下面的其他代码，而不会执行catch里面的代码注意：只有当出现了异常才会执行catch里面的代码。*/
  public class text84 {public static void main(String[] args) {int[] arr = {1, 2, 3, 4, 5, 6, 7, 8};//自己处理（捕获异常）try {System.out.println(arr[0]);System.out.println("try里面的代码执行了");//异常类名: ArrayIndexOutOfBoundsException//变量名: e} catch (ArrayIndexOutOfBoundsException e) {System.out.println("索引越界异常!" + e);}//检验代码是否执行到这一步System.out.println("try...catch体系外的代码执行了");}
  }

• 输出结果1
  

• 代码示例2：二问：如果try中可能遇见多个问题，怎么执行？

  package text.text02;/*自己处理（捕获异常）灵魂四问：二问：如果try中可能遇见多个问题，怎么执行？答：如果try中可能遇见多个问题，一般需要写多个catch与之对应。try中代码会从上往下执行，如果try中有异常没有与catch对应，则会默认采取JVM默认处理异常的方式（1.把异常的名称，异常原因及异常出现的位置等信息输出在了控制台 2.程序停止执行，异常下面的代码就不会再执行）细节：如果我们要捕获多个异常，这些异常中如果存在父子关系的话，那么父类一定要写在下面JDK7之后，可以在catch中同时捕获多个异常，中间用 | 隔开，表示如果出现了A异常或者B异常时，采用同一种处理方案*/
  public class text85 {public static void main(String[] args) {int[] arr = {1, 2, 3, 4, 5, 6, 7, 8};//JDK7以前System.out.println("JDK7以前：");//自己处理（捕获异常）try {System.out.println(10 / 0);//算术异常 ArithmeticExceptionSystem.out.println(arr[10]);//索引越界异常 ArrayIndexOutOfBoundsExceptionString str = null;System.out.println(str.equals("aaa"));//空指针异常 NullPointerException} catch (ArrayIndexOutOfBoundsException e) {System.out.println("索引越界异常!" + e);} catch (ArithmeticException e) {System.out.println("算术异常!" + e);} catch (NullPointerException e) {System.out.println("空指针异常!" + e);}//检验代码是否执行到这一步System.out.println("try...catch体系外的代码执行了");//JDK7之后，可以在catch中同时捕获多个异常，中间用 | 隔开，表示如果出现了A异常或者B异常时，采用同一种处理方案System.out.println("JDK7以后：");try {System.out.println(10 / 0);//算术异常 ArithmeticExceptionSystem.out.println(arr[10]);//索引越界异常 ArrayIndexOutOfBoundsExceptionString str = null;System.out.println(str.equals("aaa"));//空指针异常 NullPointerException} catch (ArrayIndexOutOfBoundsException | ArithmeticException | NullPointerException e) {System.out.println("出现异常!" + e);}//检验代码是否执行到这一步System.out.println("try...catch体系外的代码执行了");}
  }

• 输出结果2
  

• 代码示例3：三问：如果try中遇见的问题没有被捕获，怎么执行？

  package text.text02;/*自己处理（捕获异常）灵魂四问：三问：如果try中遇见的问题没有被捕获，怎么执行？答：如果try中遇见的问题没有被捕获,相当于try...catch体系白写了，Java会默认采取JVM默认处理异常的方式（1.把异常的名称，异常原因及异常出现的位置等信息输出在了控制台 2.程序停止执行，异常下面的代码就不会再执行）*/
  public class text86 {public static void main(String[] args) {//自己处理（捕获异常）try {System.out.println(10 / 0);//算术异常 ArithmeticException} catch (ArrayIndexOutOfBoundsException e) { //索引越界异常  ArrayIndexOutOfBoundsExceptionSystem.out.println("索引越界异常!" + e);}//检验代码是否执行到这一步System.out.println("try...catch体系外的代码执行了");}
  }

• 输出结果3
  

• 代码示例4：四问：如果try中遇见了问题，那么try下面的其他代码还会执行吗？

  package text.text02;/*
  自己处理（捕获异常）灵魂四问：
  四问：如果try中遇见了问题，那么try下面的其他代码还会执行吗？答：如果try中遇见了问题，那么try下面的其他代码不会执行了，会直接跳转到catch当中，执行catch里面的代码。如果try中有异常没有与catch对应，则会默认采取JVM默认处理异常的方式（1.把异常的名称，异常原因及异常出现的位置等信息输出在了控制台 2.程序停止执行，异常下面的代码就不会再执行）
  */
  public class text87 {public static void main(String[] args) {//自己处理（捕获异常）try {System.out.println(10 / 0);//算术异常 ArithmeticExceptionSystem.out.println("try里面的代码执行了");} catch (ArithmeticException e) {System.out.println("算术异常!" + e);}//检验代码是否执行到这一步System.out.println("try...catch体系外的代码执行了");}
  }

• 输出结果4
  

4.3 抛出处理(throw和throws)

在Java中，throw和throws是用于异常处理的关键字，用于处理和传递异常。

1. throw关键字：

   • 使用throw关键字可以手动抛出一个异常。你可以将任何继承自Throwable类的异常对象抛出。

   • throw语句通常放在条件语句或代码块中，用于在特定情况下抛出异常。

   • 抛出异常将程序的控制权交给上层调用栈，直到找到合适的异常处理器来处理异常。

   • 使用throw抛出的异常可以是受检查异常也可以是非受检查异常。

• throw:写在方法内，结束方法，手动抛出异常对象，交给调用者，方法下面的代码不再执行了

  • 格式：

  throw new 异常类名(参数);
  

  • 举例：

  throw new NullPointerException("要访问的arr数组不存在");
  throw new ArrayIndexOutOfBoundsException("该索引在数组中不存在，已超出范围");
  

2. throws关键字：
   • throws关键字用于声明一个方法可能抛出的异常类型。
   • 在方法声明中，可以使用throws关键字后跟一个异常类型或异常类型的列表，多个异常类型之间用逗号分隔。
   • 声明throws的作用是告知调用者方法可能抛出的异常，以让调用者知道需要进行相应的异常处理或继续将异常传递给上层代码。
   • 如果一个方法声明了抛出异常，而调用者没有进行处理或继续传递，那么调用者也必须使用throws关键字声明进行处理。

• throws: 写在方法定义处，表示声明一个异常，告诉调用者，使用本方法可能会有哪些异常

  • 格式：

  修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2…{   }
  

  • 举例：

  public void 方法() throws 异常类名1,异常类名2...{...}
  

    · 编译时异常：必须手写· 运行时异常：可以省略
  

• 代码示例
  练习：定义一个方法求数组的最大值

  package text.text02;/*抛出处理：
  throws: 写在方法定义处，表示声明一个异常，告诉调用者，使用本方法可能会有哪些异常格式：修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2…{   }举例：public void 方法() throws 异常类名1,异常类名2...{...}· 编译时异常：必须手写· 运行时异常：可以省略throw:写在方法内，结束方法，手动抛出异常对象，交给调用者，方法下面的代码不再执行了格式：throw new 异常类名(参数);举例：throw new NullPointerException("要访问的arr数组不存在");throw new ArrayIndexOutOfBoundsException("该索引在数组中不存在，已超出范围");练习：定义一个方法求数组的最大值*/
  public class text89 {public static void main(String[] args) {int[] arr = {1, 2, 3, 4, 56, 7, 8, 9, 10, 5, 6};int[] arr1 = null;int[] arr2 = {};int max = 0;int max1 = 0;int max2 = 0;//捕获异常try {max = getMax(arr);max1 = getMax(arr1);max2 = getMax(arr2);} catch (NullPointerException | IndexOutOfBoundsException e) {e.printStackTrace();}System.out.println(max);System.out.println(max1);System.out.println(max2);}public static int getMax(int[] arr) /* throws NullPointerException,IndexOutOfBoundsException*/ { //运行时异常：可以省略if (arr == null) {//手动创建一个异常对象，并把这个异常交给方法的调用者处理，此时方法就会结束，下面的代码不会再执行了throw new NullPointerException();//空指针异常  NullPointerException}if (arr.length == 0) {//手动创建一个异常对象，并把这个异常交给方法的调用者处理，此时方法就会结束，下面的代码不会再执行了throw new IndexOutOfBoundsException();//索引越界异常  IndexOutOfBoundsException}int max = arr[0];for (int i : arr) {if (i > max) {max = i;}}return max;}
  }

• 输出结果
  

5. 自定义异常

5.1 概述

在Java中，可以通过自定义异常来创建特定的异常类型，以便更好地处理和标识特定的异常情况。

自定义异常允许定义具有特定行为和属性的异常类，用于在程序中抛出和捕获异常。

• 目的：为了让控制台的报错信息更加的见名之意

• 步骤：

  1. 定义异常类

  2. 写继承关系

  3. 空参构造

  4. 带参构造

5.2 代码示例

• 代码示例

  • 练习：键盘录入数据：

  • 需求：

    • 1.键盘录入自己心仪的女朋友姓名和年龄，

    • 2.姓名的长度在3-10之间，

    • 3.年龄的范围为 18-40岁

    • 4.超出这个范围是异常数据不能赋值，需要重新录入,一直录到正确为止。

  • 提示: 需要考虑用户在键盘录入时的所有情况。

    • 比如:录入年龄时超出范围，录入年龄时录入了abc等情况

    package text.text02;import java.util.Scanner;/*
    自定义异常：
    目的：为了让控制台的报错信息更加的见名之意步骤：1.定义异常类2.写继承关系3.空参构造4.带参构造练习：键盘录入数据：需求：1.键盘录入自己心仪的女朋友姓名和年龄，2.姓名的长度在3-10之间，3.年龄的范围为 18-40岁4.超出这个范围是异常数据不能赋值，需要重新录入,一直录到正确为止。提示:需要考虑用户在键盘录入时的所有情况。比如:录入年龄时超出范围，录入年龄时录入了abc等情况*/
    public class text91 {public static void main(String[] args) {//空参创建学生对象girlFriend1 gf = new girlFriend1();//键盘录入Scanner sc = new Scanner(System.in);while (true) {//捕获异常try {System.out.println("请输入姓名：");String name = sc.nextLine();gf.setName(name);System.out.println("请输入年龄：");String ageString = sc.nextLine();int age = Integer.parseInt(ageString);gf.setAge(age);//如果所有的数据都是正确的，跳出循环break;} catch (NumberFormatException e) {System.out.println("年龄的格式有误，请输入数字！");e.printStackTrace();} catch (nameFormatException e) {e.printStackTrace();} catch (ageOutOfBoundsException e) {e.printStackTrace();}}System.out.println(gf.getName() + " , " + gf.getAge());}
    }//自定义姓名格式化异常
    class nameFormatException extends RuntimeException {public nameFormatException() {}public nameFormatException(String message) {super(message);}
    }//自定义年龄格式化异常
    class ageOutOfBoundsException extends RuntimeException {public ageOutOfBoundsException() {}public ageOutOfBoundsException(String message) {super(message);}
    }class girlFriend1 {private String name;private int age;public girlFriend1() {}public girlFriend1(String name, int age) {this.name = name;this.age = age;}/*** 获取** @return name*/public String getName() {return name;}/*** 设置** @param name*/public void setName(String name) {if (name.length() < 3 || name.length() > 10) {throw new nameFormatException("姓名的长度有误！");} else {this.name = name;}}/*** 获取** @return age*/public int getAge() {return age;}/*** 设置** @param age*/public void setAge(int age) {if (age < 18 || age > 40) {throw new ageOutOfBoundsException("年龄的范围有误！");} else {this.age = age;}}public String toString() {return "girlFriend{name = " + name + ", age = " + age + "}";}
    }

• 输出结果
  

6. 异常注意事项

1. 运行时异常被抛出可以不处理。即不捕获也不声明抛出。

2. 如果父类抛出了多个异常,子类覆盖父类方法时,只能抛出相同的异常或者是他的子集。

3. 父类方法没有抛出异常，子类覆盖父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出

4. 当多异常处理时，捕获处理，前边的类不能是后边类的父类

5. 在try/catch后可以追加finally代码块，其中的代码一定会被执行，通常用于资源回收。