java异常

目录

1.异常

1.1异常的概述

1.2异常的体系

1.3 在jvm中默认处理异常的机制

2. 处理异常的方式

2.1有两大类处理异常的方式：

2.2 异常捕获的第一种格式

2.3 异常捕获的第一种格式的多种异常情况

2.4 异常捕获的第二种格式

2.5 异常处理的第三种格式

3. 继承体系中的常用方法

4.自定义异常

4.1 throw关键字

4.2 throws关键字

4.3 throw和throws的比较

4.4 自定义异常类

---

1.异常

1.1异常的概述

• 在java程序《运行》过程中,出现的不正常情况,出现的错误,称为异常

• 异常就是一个对象,描述那些不符合生活正常情况的异常情况，包含了这些情况的原因、类型、描述以及位置,这些内容都封装到异常对象中。

• 异常也是一种处理异常情况的机制，可以进行跳转、捕获以及结束程序,提供了程序退出的安全通道

• 

1.2异常的体系

• Throwable:可抛出的,是异常体系的顶层父类,其它的异常或者错误都是Throwable的子类类型,只有Throwable的体系类型,才可以使用异常的处理机制

• Error:错误,是Throwable的子类，用于描述那些无法捕获和处理的错误情况,属于非常严重的错误,StackOverflowError

• Exception:异常,是Throwable的子类，用于描述那些可以捕获和处理的例外情况,属于不太严重的错误ArrayIndexOutOfBoundsException,NullPointerException

• RuntimeException：运行时异常,是Exception的特殊的子类，在编译阶段不做检查的一个异常

  这种异常我们不需要处理，由虚拟机掌管，比如NullPointerException,ArrayIndexOutOfBoundsException

• 体系图:

  

1.3 在jvm中默认处理异常的机制

• 演示代码：

/**
 * 在jvm中 默认处理异常的机制
 */
public class Simple01 {
?
 ? ?public static void main(String[] args) {
 ? ? ? ?test1();
 ?  }
?
 ? ?public static void test1() {
 ? ? ? ?test2();
 ?  }
?
 ? ?public static void test2() {
 ? ? ? ?test3();
 ?  }
?
 ? ?public static void test3() {
 ? ? ? ?int i = 1 / 0;
 ? ? ? ?System.out.println(i);
 ?  }
}

• 在代码的某个位置,出现了和正常情况不同的情况，就将异常情况封装到一个异常对象中。

• 将异常对象抛给调用该方法的方法,A调用B, B有问题就把异常抛给A。

• 某个方法接收到底层方法抛上来的异常,也没有办法自己处理，继续向上抛出,最终抛给main方法,main方法也没有办法处理,抛给调用自己的jvm虚拟机

• Jvm虚拟机是我们手动调用的，只能将异常对象的所有信息，通过错误信息打印出来，结束jvm虚拟机

• 总结，jvm默认处理的方式：【一层一层向上抛，jvm接收到之后结束自己】

2. 处理异常的方式

2.1有两大类处理异常的方式：

• 异常的声明:某个方法有编译时异常，编译就会无法通过，需要在异常所在的方法声明上，声明该方法可能出现的编译时异常

  public ?static void ?test () throws FileNotFoundException 
  {
  FileInputStream fileInputStream = new FileInputStream("/Users/lihongyan/Desktop/未命名.html");
   }
  ?
  JDK11新增方式
  Path path = Paths.get("/Users/lihongyan/Desktop/未命名.html");
  String data = Files.readString(path);
  System.out.println(data);

• 异常的捕获：出现异常之后，可以通过某些格式来捕获,可以让程序在出现异常之后,继续运行,可以定义自己处理异常的逻辑。

• 捕获处理异常的代码格式：

  • try...catch

  • try...catch...finally

  • try...finally（无法捕获处理异常）

2.2 异常捕获的第一种格式

• 格式

  • try ? {
     ? ? ?   可能发生异常的代码
     ? ?  } catch(可能出现异常的类型 标识符) {
                    这种异常出现之后的处理方式
     ? ?  }

• try：试一试

  • try语句块中，是可能会运行失败的代码，try语句是用于对异常进行检测

• catch：抓住、捕获

  • 抓住try语句中出现的异常，并且定义异常处理的方式

• 运行机制：

  • 运行try语句中的代码

  • 如果没有发生任何异常，那么不再运行catch块中的内容

  • 如果发生了catch中声明的异常，那么就会被捕获到这个异常，执行catch块中的内容（try中如果发生了异常，try中，该语句后面的代码都无法执行了，直接跳到catch中）

  • 如果发生了catch中没有声明的异常，那么就无法捕获该异常，该异常的处理就使用jvm的默认处理方式

2.3 异常捕获的第一种格式的多种异常情况

• 在一段代码中,可能出现多种异常(虽然一次运行只能出现一个异常,但是出现哪个异常我们是不清楚的),所以要准备多种异常情况的处理机制。

• 格式：

• try {
          可能出现异常的代码
  } catch (异常类型1 ?异常对象名1) {
      异常类型1出现之后的处理办法
  } catch (异常类型2 ?异常对象名2) {
      异常类型2出现之后的处理办法
  }
  ....
  } catch (异常类型n 异常对象名n) {
      异常类型n出现之后的处理办法
  }

• 执行流程：

  • 执行try中的内容，如果没有异常，try...catch语句直接结束

  • 如果有异常，那么就在发生异常的代码位置直接跳转到catch块中，try中后面的代码就不再继续运行了

  • 继续匹配各个catch块中的异常类型，从上到下，一旦匹配到某个catch声明的异常类型，就直接执行该catch块的处理方式。处理完成之后，try...catch语句就直接结束了，不会再去匹配后面其他的catch块的异常类型

• 代码示例:

/**
 * 异常捕获的第一种格式的多种异常情况
 */
public class Simple02 {
?
 ? ?public static void main(String[] args) {
 ? ? ? ?test();
 ?  }
?
 ? ?public static void test() {
 ? ? ? ?Scanner sc = new Scanner(System.in);
 ? ? ? ?System.out.println("请录入一个除数");
 ? ? ? ?try {
 ? ? ? ? ? ?int i = 100 / sc.nextInt();
 ? ? ? ? ? ?System.out.println(i);
 ? ? ? ? ? ?int[] arr = {1, 3, 5, 7, 9};
 ? ? ? ? ? ?System.out.println(arr[5]);
 ? ? ?  }
 ? ? ? ? ?catch (ArithmeticException a) {
 ? ? ? ? ? System.out.println("出现数学运算异常");
 ? ? ?  } catch ( ArrayIndexOutOfBoundsException a) {
 ? ? ? ? ? System.out.println("出现索引越界异常");
 ? ? ?  }
 ? ? ? ?// catch (ArithmeticException  | ArrayIndexOutOfBoundsException a) {
 ? ? ? ?// ? ? System.out.println(a.getMessage());
 ? ? ? ?// }
 ?  }
}
?

• 注意事项：

  • 如果在各个catch块中，出现了子父类的异常类型，那么子类异常的catch块，必须在父类异常catch块的上面，因为从上到下匹配方式，如果父类的catch块在上面，下面的catch块就没有出现的意义了。

  • 在jdk1.7之后，可以对异常类型进行逻辑的或运算，使用|表示，多种异常类型，可以使用相同的处理方式：

• catch(异常类型1 | 异常类型2 ?异常对象名称) {
              异常类型1和2的共同处理方式a.getMessage()
  }

2.4 异常捕获的第二种格式

• 格式：

• try {
          可能发生异常的代码
        } 
   ?catch (可能发生的异常类型 ?异常对象名称) {
           当前异常类型的处理方式
  } ?finally {
       ? 一定要执行的代码
  }

• finally：一定要执行的代码

  • 如果把某句代码放在try中，可能在这句话前面有异常，那么这句话就无法执行；如果把某句代码放在catch中，有可能try中没有异常，就无法执行这句话；如果把某句代码放在try...catch之后，可能有未捕获的异常，那么这句代码也无法执行。

  • finally：也是一个代码块，在这个代码块中的代码，一定会执行，无论上面描述的哪种情况，都会执行。

  • 作用：一般使用关闭资源

  • -示例代码:

/**
 * 异常捕获的第二种格式
 */
public class Simple03 {
?
 ? ?public static void main(String[] args) {
 ? ? ? ?test();
 ?  }
?
 ? ?public static void test() {
 ? ? ? ?Scanner sc = new Scanner(System.in);
 ? ? ? ?System.out.println("请录入一个除数");
 ? ? ? ?try {
 ? ? ? ? ? ?int i = 100 / sc.nextInt();
 ? ? ? ? ? ?System.out.println(i);
 ? ? ? ? ? ?int[] arr = {1, 3, 5, 7, 9};
 ? ? ? ? ? ?System.out.println(arr[5]);
 ? ? ?  }
 ? ? ? ? catch (ArithmeticException ?| ArrayIndexOutOfBoundsException a) {
 ? ? ? ? ? ? System.out.println(a.getMessage());
 ? ? ? ? } finally {
 ? ? ? ? ? ?System.out.println("我一定要执行");
 ? ? ?  }
 ?  }
}

2.5 异常处理的第三种格式

• 格式：

• try {
          可能发生异常的代码
  } finally {
      一定要执行的代码
  }

• 作用：

  • 第三种格式无法捕获和处理异常，一旦发生任何异常，仍然会按照默认的处理方式，一层一层向上抛出，到达jvm，结束虚拟机

  • 无论try中的语句是否发生异常，finally中的代码都一定有执行的机会

  • 如果有两句代码，都需要有执行的机会，不希望第一句的成功与否影响到第二句的执行机会，那么就把这两句代码分别放在try和finally中，就是try中你报你的错，我finally中代码该咋执行咋执行。

• 代码示例：

import java.util.Scanner;
?
/**
 * 异常处理的第三种格式
 */
public class Simple04 {
 ? ?public static void main(String[] args) {
 ? ? ? ?try {
 ? ? ? ? ? ?System.out.println("输入一个除数");
 ? ? ? ? ? ?System.out.println(1 / new Scanner(System.in).nextInt());
 ? ? ?  } finally {
 ? ? ? ? ? ?System.out.println("一定有机会执行的代码");
 ? ? ?  }
 ?  }
}

3. 继承体系中的常用方法

• 在异常的继承体系中，所有的方法定义在了Throwable这个顶层父类中，子类中几乎没有什么特有方法

• Throwable中的构造方法： Throwable()：创建一个没有任何参数的异常对象 Throwable(String message)：创建一个带有指定消息的异常对象 Throwable(Throwable cause)：创建一个有原因异常的异常对象

• 常用成员方法： getMessage()：获取异常的详细信息 toString()：获取异常对象的详细信息 printStackTrace()：打印异常的调用栈轨迹（有关异常的方法调用路径）

• 代码示例:

import java.util.Scanner;
?
/**
 * 继承体系中的常用方法
 */
public class Simple05 {
 ? ?public static void main(String[] args) {
 ? ? ? ?test();
 ?  }
 ? ?private static void test() {
 ? ? ? ?try {
 ? ? ? ? ? ?System.out.println("输入一个除数");
 ? ? ? ? ? ?System.out.println(1 / new Scanner(System.in).nextInt());
 ? ? ?  } catch (ArithmeticException ae) { ? // 这里可以介绍一下exception异常
 ? ? ? ? ? ?System.out.println(ae.getMessage());//获取当前异常对象的消息字符串
 ? ? ? ? ? ?System.out.println(ae.toString());//获取当前异常对象的字符串描述
 ? ? ? ? ? ?System.out.println("--------------------------");
 ? ? ? ? ? ?ae.printStackTrace();//获取当前异常对象的方法调用路径
 ? ? ?  }
 ?  }
}

4.自定义异常

4.1 throw关键字

• throw：抛出,用于抛出一个异常对象

• 异常是一个对象，当程序运行到某种情况时，程序员认为这种情况和现实生活不符合，就把当前的对于情况的描述，封装到一个异常对象中，通过throw关键字将异常对象进行抛出。

• 作用： 创建一个异常对象，使用throw关键字抛出，实现了程序的结束或者跳转

• 说明：

• 如果抛出的是运行时异常，在编译阶段就相当于没有异常，可以不处理这个异常
  如果抛出的是编译时异常，那么这个异常必须使用异常处理的方式处理，才能编译成功

• 代码示例

public class Simple06 {
 ? ?public static void main(String[] args) {
 ? ? ? ?test();
 ?  }
 ? ?private static void test() {
 ? ? ? ?Person person = new Person();
 ? ? ? ?person.setName("小明");
 ? ? ? ?try {
 ? ? ? ? ? ?person.setAge(-20);
 ? ? ?  }catch ( RuntimeException re) {
 ? ? ? ? ? ?System.out.println(re.getMessage());
 ? ? ?  }
 ? ? ? ?System.out.println(person);
 ?  }
}
?
public class Person {
 ? ?private ?String name;
 ? ?private Integer age;
?
 ? ?public Person(String name, Integer age) {
 ? ? ? ?this.name = name;
 ? ? ? ?this.age = age;
 ?  }
?
 ? ?public String getName() {
 ? ? ? ?return name;
 ?  }
?
 ? ?public Person() {
 ?  }
?
 ? ?public void setName(String name) {
 ? ? ? ?this.name = name;
 ?  }
?
 ? ?public Integer getAge() {
 ? ? ? ?return age;
 ?  }
?
 ? ?public void setAge(Integer age) {
 ? ? ? ?if (age <= 0) {
 ? ? ? ? ? ?// 年龄小于0，这种情况不符合生活正常情况，就将这种情况封装成异常对象
 ? ? ? ? ? ?// 如果抛出的是运行时异常，在编译阶段就相当于没有异常，可以不处理这个异常
 ? ? ? ? ? ?// RuntimeException re = new RuntimeException();
 ? ? ? ? ? ?// throw re;//将异常对象
 ? ? ? ? ? throw new RuntimeException("年龄不能为负值");
?
 ? ? ?  }
 ? ? ? ?this.age = age;
 ?  }
 ? ?@Override
 ? ?public String toString() {
 ? ? ? ?return "Person{" +
 ? ? ? ? ? ? ? ?"name='" + name + '\'' +
 ? ? ? ? ? ? ? ?", age=" + age +
 ? ? ? ? ? ? ? ?'}';
 ?  }
}

4.2 throws关键字

• throws：抛出,用于声明一个异常类型

• 在某个方法中，有一些编译时异常，没有给出处理的方案，没有捕获这个异常，没有处理这个异常，就说明这个方法是一个有问题的方法。为了让调用者在调用时，可以考虑到处理这个异常，所必须在当前方法的声明上，声明这个异常。

• 声明格式：

  修饰符 返回值类型 方法名称(参数列表) throws 异常类型1, 异常类型2,... {
   ?      可能出现异常的代码
  }

• 注意事项：

  • 如果抛出的是一个运行时异常，那么就相当于没有抛出异常，这种异常也不需要在方法上声明；声明了一个运行时异常，也相当于没有做任何声明

  • 如果抛出的是一个编译时异常，那么就必须进行声明或者捕获；如果声明了一个编译时异常，将来调用这个方法时，也相当于有一个声明的异常。

  • 在声明异常的时候，尽量声明<小>的异常、尽量声明<少>的异常

  • 一个方法暴露太多异常，别人不敢调用你了

  • 代码示例：

?

public class Simple07 {
 ? ?public static void main(String[] args) {
 ? ? ? ?test();
 ?  }
 ? ?private static void test() {
 ? ? ? ?Person person = new Person();
 ? ? ? ?person.setName("小明");
 ? ? ? ?try {
 ? ? ? ? ? ?person.setAge(-20);
 ? ? ?  }catch ( Exception re) {
 ? ? ? ? ? ?System.out.println(re.getMessage());
 ? ? ?  }
 ? ? ? ?System.out.println(person);
 ?  }
}
?
public class Person {
 ? ?private ?String name;
 ? ?private Integer age;
?
 ? ?public Person(String name, Integer age) {
 ? ? ? ?this.name = name;
 ? ? ? ?this.age = age;
 ?  }
?
 ? ?public String getName() {
 ? ? ? ?return name;
 ?  }
?
 ? ?public Person() {
 ?  }
?
 ? ?public void setName(String name) {
 ? ? ? ?this.name = name;
 ?  }
?
 ? ?public Integer getAge() {
 ? ? ? ?return age;
 ?  }
?
 ? ?public void setAge(Integer age) throws Exception {
 ? ? ? ?if (age <= 0) {
 ? ? ? ? ? ?// 年龄小于0，这种情况不符合生活正常情况，就将这种情况封装成异常对象
 ? ? ? ? ? ?// 创建编译时 异常
 ? ? ? ? ? throw new Exception("年龄不能为负值");
?
 ? ? ?  }
 ? ? ? ?this.age = age;
 ?  }
?
 ? ?@Override
 ? ?public String toString() {
 ? ? ? ?return "Person{" +
 ? ? ? ? ? ? ? ?"name='" + name + '\'' +
 ? ? ? ? ? ? ? ?", age=" + age +
 ? ? ? ? ? ? ? ?'}';
 ?  }
}
?

4.3 throw和throws的比较

• throw是对异常对象的抛出，throws是对异常类型的声明

• throw是对异常对象实实在在的抛出，一旦使用了throw关键字，就一定有一个异常对象出现；

  throws是对可能出现的异常类型的声明，即使声明了异常类型，在该方法中，也可能不出现任何异常。

• throw后面只能跟一个异常对象；

  throws可以跟很多个异常类型

4.4 自定义异常类

public class Simple08 {
 ? ?public static void main(String[] args) {
 ? ? ? ?test1();
 ? ? ? ?test2();
 ? ?try {
 ? ? ? ? test3();
 ? ? } catch (ExceptionDemo2 e) {
 ? ? ? ? System.out.println(e.getMessage());
 ? ? }
 ?  }
 ? ?private static void test1() ?throws ?ExceptionDemo1 {
 ? ? ? ?String str = null;
 ? ? ? ?System.out.println(str.length());
 ?  }
 ? ?private static void test2() ?throws ExceptionDemo2 {
 ? ? ? ?String str = null;
 ? ? ? ?System.out.println(str.length());
 ?  }
 ? ?private static void test3() {
 ? ? ? ?throw new ExceptionDemo2("异常");
 ?  }
}
?
class ExceptionDemo1 extends ?RuntimeException {
?
}
class ExceptionDemo2 extends ?Exception {
 ? ?public ExceptionDemo2(String message) {
 ? ? ? ?super(message);
 ?  }
?
 ? ?public ExceptionDemo2() {
 ?  }
}