Java学习苦旅（十五）——异常
本篇博客将讲解Java中的异常。
文章目录
- 异常简介
-
- 什么是异常
- 常见的异常
-
- 除以0
- 数组下标越界
- 访问null对象
- 防御式编程
- 异常的好处
- 异常的基本用法
-
- 捕获异常
-
- 基本语法
- 代码示例1
- 代码示例2
- 代码示例3
- 代码示例4
- 代码示例5
- 代码示例6
- 代码示例7
- 代码示例8
- 抛出异常
- Java异常体系
- 自定义异常类
- 结尾
异常简介
什么是异常
所谓异常指的就是程序在 运行时 出现错误时通知调用者的一种机制。
关键字运行时有些错误是这样的，比如将 System.out.println 拼写错了, 写成了 system.out.println. 此时编译过程中就会出错, 这是编译期出错。而运行时指的是程序已经编译通过得到了class文件了，再由JVM执行过程中出现的错误。
异常的种类有很多，不同种类的异常具有不同的含义，也有不同的处理方式。
常见的异常
除以0
System.out.println(10/0);
结果为：
数组下标越界
int[] array = {1,2,3};
System.out.println(array[10]);
结果为：
访问null对象
public class TestDemo {
public int a = 10;
public static void main(String[] args) {
TestDemo m = null;
System.out.println(m.a);
}
}
结果为：
防御式编程
错误在代码中是客观存在的，因此我们要让程序出现问题的时候及时通知程序员，我们有两种主要的方式：
LBYL：Look Before You Leap。在操作之前就做充分的检查。
EAFP：It’s Easier to Ask Forgiveness than Permission。“事后获取原谅比事前获取许可更容易”。也就是先操作，遇到问题再处理。
异常的核心思想就是 EAFP。
异常的好处
例如写这样一段代码：
LBYL风格的代码（不使用异常）
boolean ret = false;
ret = 登陆游戏();
if (!ret) {
处理登陆游戏错误;
return;
}
ret = 开始匹配();
if (!ret) {
处理匹配错误;
return;
}
ret = 游戏确认();
if (!ret) {
处理游戏确认错误;
return;
}
ret = 选择英雄();
if (!ret) {
处理选择英雄错误;
return;
}
ret = 载入游戏画面();
if (!ret) {
处理载入游戏错误;
return;
}
EAFP风格的代码（使用异常）
try {
登陆游戏();
开始匹配();
游戏确认();
选择英雄();
载入游戏画面();
...
} catch (登陆游戏异常) {
处理登陆游戏异常;
} catch (开始匹配异常) {
处理开始匹配异常;
} catch (游戏确认异常) {
处理游戏确认异常;
} catch (选择英雄异常) {
处理选择英雄异常;
} catch (载入游戏画面异常) {
处理载入游戏画面异常;
}
...
对比两种不同风格的代码，我们可以发现，使用第一种方式，正常流程和错误处理流程代码混在一起，代码整体显的比较混乱。而第二种方式正常流程和错误流程是分离开的，更容易理解代码。
异常的基本用法
捕获异常
基本语法
try{
有可能出现异常的语句 ;
} catch (异常类型 异常对象) {
}
...
finally {
异常的出口
}
- try代码块中放的是可能出现异常的代码。
- catch代码块中放的是出现异常后的处理行为。
- finally代码块的代码用于处理善后工作，会在最后执行。
- 其中catch和finally都可以根据情况选择加或者不加。
代码示例1
int[] array = {1,2,3};
System.out.println("before");
System.out.println(array[100]);
System.out.println("after");
执行结果为：
因此，一旦出现异常，程序就终止了。after没有正确输出。
代码示例2
使用try catch后的程序执行过程
int[] array = {1,2,3};
try {
System.out.println("before");
System.out.println(array[100]);
System.out.println("after");
} catch (ArrayIndexOutOfBoundsException e) {
e.printStackTrace();
}
System.out.println("======================");
执行结果为：
我们发现，一旦 try 中出现异常，那么 try 代码块中的程序就不会继续执行，而是交给 catch 中的代码来执行，catch 执行完毕会继续往下执行。
关于异常的处理方式
异常的种类有很多，我们要根据不同的业务场景来决定。
对于比较严重的问题（例如和算钱相关的场景），应该让程序直接崩溃, 防止造成更严重的后果。
对于不太严重的问题（大多数场景），可以记录错误日志，并通过监控报警程序及时通知程序员。
对于可能会恢复的问题（和网络相关的场景），可以尝试进行重试。
在我们当前的代码中采取的是经过简化的第二种方式，我们记录的错误日志是出现异常的方法调用信息，能很快速的让我们找到出现异常的位置，以后在实际工作中我们会采取更完备的方式来记录异常信息。
关于调用栈
方法之间是存在相互调用关系的，这种调用关系我们可以用”调用栈“来描述。在 JVM 中有一块内存空间称为”虚拟机栈“专门存储方法之间的调用关系. 当代码中出现异常的时候， 我们就可以使用
e.printStackTrace();的方式查看出现异常代码的调用栈.
代码示例3
catch 只能处理对应种类的异常，例如：
int[] array = {1,2,3};
try {
System.out.println("before");
array = null;
System.out.println(array[100]);
System.out.println("after");
} catch (ArrayIndexOutOfBoundsException e) {
e.printStackTrace();
}
System.out.println("======================");
运行结果为：
此时，catch 语句不能捕获到刚才的空指针异常，因为异常类型不匹配。
代码示例4
int[] array = {1,2,3};
try {
System.out.println("before");
array = null;
System.out.println(array[100]);
System.out.println("after");
} catch (ArrayIndexOutOfBoundsException e) {
e.printStackTrace();
} catch (NullPointerException e) {
e.printStackTrace();
}
System.out.println("======================");
执行结果为：
一段代码可能会抛出多种不同的异常，不同的异常有不同的处理方式。因此可以搭配多个 catch 代码块。如果多个异常的处理方式是完全相同，也可以写成这样：
catch (ArrayIndexOutOfBoundsException | NullPointerException e) {
...
}
代码示例5
一个catch可以捕获所有异常，但不推荐，例如：
int[] array = {1,2,3};
try {
System.out.println("before");
array = null;
System.out.println(array[100]);
System.out.println("after");
} catch (Exception e) {
e.printStackTrace();
}
执行结果为：
由于 Exception 类是所有异常类的父类。因此可以用这个类型表示捕捉所有异常。
catch捕获异常的时候，从上到下，最好是子类到父类。
代码示例6
finally 表示最后的善后工作, 例如释放资源，比如：
int[] array = {1,2,3};
try {
System.out.println("before");
array = null;
System.out.println(array[100]);
System.out.println("after");
} catch (Exception e) {
e.printStackTrace();
} finally {
System.out.println("finally code");
}
执行结果为：
无论是否存在异常，finally 中的代码一定都会执行到，保证最终一定会执行到 Scanner 的 close 方法。
代码示例7
将 Scanner 对象在 try 的 ( ) 中创建，就能保证在 try 执行完毕后自动调用 Scanner的 close 方法，例如：
try (Scanner sc = new Scanner(System.in)) {
int num = sc.nextInt();
System.out.println("num = " + num);
} catch (Exception e) {
e.printStackTrace();
}
代码示例8
finally当中尽量避免出现return，例如：
public static int fun(int n) {
try {
return n;
} catch (NullPointerException e) {
e.printStackTrace();
} finally {
return 100;
}
}
public static void main(String[] args) {
System.out.println(fun(10));
}
执行结果为：
异常处理流程
-
程序先执行 try 中的代码。
-
如果 try 中的代码出现异常，就会结束 try 中的代码，观察和 catch 中的异常类型是否匹配。
-
如果找到匹配的异常类型，就会执行 catch 中的代码。
-
如果没有找到匹配的异常类型，就会将异常向上传递到上层调用者。
-
无论是否找到匹配的异常类型，finally 中的代码都会被执行到（在该方法结束之前执行）。
-
如果上层调用者也没有处理的了异常，就继续向上传递。
-
一直到 main 方法也没有合适的代码处理异常，就会交给 JVM 来进行处理，此时程序就会异常终止。
抛出异常
除了 Java 内置的类会抛出一些异常之外，程序员也可以手动抛出某个异常，使用 throw 关键字完成这个操作，例如：
public static int divide(int x, int y) {
if (y == 0) {
throw new ArithmeticException("抛出除 0 异常");
}
return x / y;
}
public static void main(String[] args) {
System.out.println(divide(10, 0));
}
执行结果为：
在这个代码中，我们可以根据实际情况来抛出需要的异常，在构造异常对象同时可以指定一些描述性信息。
Java异常体系
下图表示Java内置的异常类之间的继承关系：
-
顶层类
Throwable派生出两个重要的子类：Error和Exception。 -
其中
Error指的是 Java 运行时内部错误和资源耗尽错误，应用程序不抛出此类异常。这种内部错误一旦出现，除了告知用户并使程序终止之外，再无能无力。这种情况很少出现。 -
Exception是我们程序猿所使用的异常类的父类。 -
其中
Exception有一个子类称为RuntimeException，这里面又派生出很多我们常见的异常类NullPointerException，IndexOutOfBoundsException等。
Java语言规范将派生于Error类或RuntimeException类的所有异常称为 非受查异常，所有的其他异常称为 受查异常。
如果一段代码可能抛出 受查异常，那么必须显式进行处理，例如：
public static String readFile() {
File file = new File("d:/test.txt");
Scanner sc = new Scanner(file);
return sc.nextLine();
}
public static void main(String[] args) {
System.out.println(readFile());
}
执行结果为：
因此需要进行显示处理，显示处理的方法有两种：
- 使用try catch包裹起来
public static String readFile() {
File file = new File("d:/test.txt");
Scanner sc = null;
try {
sc = new Scanner(file);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
return sc.nextLine();
}
public static void main(String[] args) {
System.out.println(readFile());
}
执行结果为：
- 在方法上加上异常说明，相当于将处理动作交给上级调用者
public static String readFile() throws FileNotFoundException {
File file = new File("d:/test.txt");
Scanner sc = new Scanner(file);
return sc.nextLine();
}
public static void main(String[] args) {
try {
System.out.println(readFile());
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
执行结果为：
自定义异常类
Java 中虽然已经内置了丰富的异常类，但是我们实际场景中可能还有一些情况需要我们对异常类进行扩展，创建符合我们实际情况的异常，例如：
class NameException extends RuntimeException {
public NameException(String message) {
super(message);
}
}
class PasswordException extends RuntimeException {
public PasswordException(String message) {
super(message);
}
}
public class TestDemo2 {
private static final String name = "abc";
private static final String password = "123456";
public static void login(String name, String password) throws NameException,PasswordException {
if (!TestDemo2.name.equals(name)) {
throw new NameException("用户名错误");
}
if (!TestDemo2.password.equals(password)) {
throw new PasswordException("密码错误");
}
}
public static void main(String[] args) {
try {
login("abc","12345");
} catch (NameException e){
System.out.println("用户名错误！");
} catch (PasswordException e) {
System.out.println("密码错误！");
} finally {
System.out.println("finally执行了！");
}
}
}
执行结果为：
注意事项
- 自定义异常通常会继承自 Exception 或者 RuntimeException。
- 继承自 Exception 的异常默认是受查异常。
- 继承自 RuntimeException 的异常默认是非受查异常。
结尾
本篇博客到此结束。
上一篇博客：Java学习苦旅（十四）——String
下一篇博客：Java学习苦旅（十六）——List