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() {
}
}