目录
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() {
}
}
262
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
