Java 异常机制
1. 什么是异常
-
实际工作中，遇到的情况不可能是非常完美的。比如：你写的某个模块，用户输入不一定符合你的要求；你的程序要打开某个文件，这个文件可能不存在或者文件格式不对；你要读取数据库的数据，数据可能是空的；我们的程序在跑着，内存或硬盘可能就满了等等。
-
软件程序在运行过程中，非常可能遇到刚刚提到的这些异常问题，我们称它们为异常，英文名为：Exception ，意思是例外。这些例外的情况，或者异常，怎么让我们写的程序做出合理的处理，而不至于导致程序崩溃。
-
异常指的是程序运行中出现的不期而至的各种情况，如：文件找不到、网络连接失败、非法参数等。
-
异常发生在程序运行期间，它影响着正常的程序执行的流程。
-
用一些实例简单了解一些异常，如下：
// 创建 Demo 类 public class Demo{ public static void main(String[] args){ System.out.println(11/0); // 被除数不能为0 } }运行结果为：
Java 程序里存在的异常有很多，这里不过多说明。
异常简单分类
要理解 Java 异常处理是如何工作的，需要我们掌握以下三种类型的异常：
-
检查性异常：
最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如：要打开一个不存在的文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
-
运行时异常：
运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
-
错误 ERROR ：
错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如：当栈溢出时，一个错误就发生了，它们在编译时也检查不到。
2. 异常体系机制
Java 语言在设计之初，就考虑到了这些异常的存在了。
-
Java 把异常当作对象来处理，并定义一个基类
java.lang.Throwable作为所有异常的超类。 -
在 Java API 中已定义了许多异常类，这些异常类分为两大类，错误 Error 和异常 Exception 。
所有的异常都是 Throwable 的子类，关系如上图所示（图中列举的异常也只是一部分）。
我们主要说说 Error 和 Exception 异常，如下：
Error
- Error 类对象由 Java 虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关。
- Java 虚拟机运行错误（
Vitual MachineError），当 JVM 不再有继续执行操作所需的内存资源时，将出现OutOfMemoryError。这些异常发生时，Java 虚拟机（ JVM ）一般会选择线程终止。 - 还有发生在虚拟机试图执行应用时，如类定义错误（
NoClassDefFoundError）、链接错误（LinkageError）。这些错误是不可查的，因为它们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况。
Exception
-
在 Exception 分支中有一个重要的子类
RuntimeException（运行时异常）。ArrayIndexOutOfBoundsException（数组下标越界）NullPointerException（空指针异常）ArithmeticException（算术异常）MissingResourceException（丢失资源）ClassNotFoundException（找不到类）
除了这些异常外，还有其他许多的异常，而上面列举的异常是不检查异常，程序中可以选择捕获处理，也可以不处理。
-
这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。
-
Error 和 Exception 异常的区别：
- Error 异常，通常是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常时，Java 虚拟机（JVM）一般会选择终止线程。
- Exception 异常，通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常。
3. Java 异常处理机制
Java 中异常处理机制无非就是如何抛出异常和如何捕获异常。
异常处理的五个关键字：
- try 、catch 、finally 、throw 、throws 。
捕获异常
我们先说说如何捕获异常，实例代码如下：
// 创建一个 Test 类
public class Test{
public static void main(String[] args){
int a = 2; // 定义两个 int 型变量并赋值
int b = 0;
// 捕获异常
try{ // try 监控区域
System.out.println(a / b);
}catch(ArithmeticException e){ // catch 捕获异常
System.out.println("程序出现异常，变量b不能为0");
}finally{ // finally 处理善后工作
System.out.println("finally");
}
}
}
运行结果为：
我们在程序中编写了 try / catch 语句，那么程序就不会报错，会根据你编写的程序来执行。就如上面简单的例子，如果我们不加 try / catch 语句，直接输出结果（System.out.println(a / b);），那么运行后，程序会报错，如下图：
- 捕获异常时，try / catch 语句必须有，finally 可以没有。
- finally 一般是关闭 IO 流时存在，在 finally 里关闭 IO 流资源。
- 无论 try / catch 语句是否执行，finally 语句都会运行。
- catch 语句后面的括号里是我们想要捕获的异常类型。
捕获异常时，catch 语句也可以编写多个，但是要从小到大排序（异常类型），不然执行了大的异常类型后，就不会执行其他的 catch 语句了。
public class Test{
public static void main(String[] args){
int a = 2; // 定义两个 int 型变量并赋值
int b = 0;
// 捕获异常
try{ // try 监控区域
System.out.println(a / b);
}catch(Error e){ // catch 捕获异常
System.out.println("Error");
}catch(Exception e){
System.out.println("Exception");
}catch(Throwable t){
System.out.println("Throwable");
}finally{ // finally 处理善后工作
System.out.println("finally");
}
}
}
运行结果为：
因为程序会捕获到 ArithmeticException 异常，而这个异常是 Exception 的子类，所以会运行 Exception 类型的 catch 语句。
- 假设要捕获多个异常：从小到大！
如果你想自动生成 try / catch 语句，选中你想捕获异常的代码，按住 Ctrl + Alt + T ，找到 try / catch 、 try / finally 或者 try / catch / finally，我们一般选择 try / catch / finally 语句，选择后会自动在你选中的代码加上捕获异常语句（异常类型也会自动生成）。如下图：
选择后 catch 语句里会出现 e.printStackTrace(); ，意思就是打印错误的栈信息。
运行后，打印出的错误就是运行程序后所报出的异常。
抛出异常
我们原本就知道程序会出错，主动抛出一个异常，实例如下：
public class Test02 {
public static void main(String[] args) {
// 实例化 Test02 类
new Test02().test(1,0);
}
// 方法
public void test(int a,int b) {
if (b == 0) { // 如果被除数为0，则抛出异常
throw new ArithmeticException(); // 主动的抛出异常 throw 关键字
}
System.out.println(a / b);
}
}
运行结果为：
主动抛出的异常，即使我们上面的代码 System.out.println(a / b); ，同样也会抛出异常。只要满足条件，程序运行后，就会抛出编写的异常。
- 主动抛出异常一般在方法中使用。
如果这方法，处理不了这个异常，可以往外抛出（方法上抛出异常）。
public class Test02 {
public static void main(String[] args) {
// 实例化 Test02 类
try {
new Test02().test(1,0);
} catch (ArithmeticException e) {
e.printStackTrace();
} finally {
}
}
// 方法
public void test(int a,int b) throws ArithmeticException{ // 向外抛出异常 throws 关键字
if (b == 0) { // 如果被除数为0，则抛出异常
throw new ArithmeticException(); // 主动的抛出异常 throw 关键字
}
System.out.println(a / b);
}
}
向外抛出异常后，必须要在调用方法的代码上添加 try / catch 语句来捕获这个异常，不然程序运行不了，会停住。如果针对非检查性异常，即使你不加 try / catch 语句，程序运行后，也会自主的报出异常。我这里只是简单介绍了一下，例子比较随意。
4. 自定义异常
- 使用 Java 内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类，只需继承 Exception 类即可。
- 在程序中使用自定义异常类，大体可分为以下几个步骤：
- 创建自定义异常类。
- 在方法中通过 throw 关键字抛出异常对象。
- 如果在当前抛出异常的方法中处理异常，可以使用 try / catch 语句捕获并处理；否则在方法的声明处通过 throws 关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
- 在出现异常方法的调用者中捕获并处理异常。
下面介绍如何创建自定义异常类，实例如下：
// 创建自定义异常类 MyException
public class MyException extends Exception{
// 传递数字 > 10
private int detail;
// 有参构造
public MyException(int a){
this.detail = a;
}
// toString 打印异常信息
public String toString(){
return "MyException{" + detail + "}";
}
}
前面说道，抛出异常有两种处理方法：
- 第一种，就是在方法里捕获异常，对抛出异常的代码添加 try / catch 语句。
- 第二种，向外抛出异常（方法上抛出异常），让调用该方法的代码添加 try / catch 语句。
下面一一说明，用一个 Test 类来测试一下。
-
第一种，方法里抛出异常。
// 创建 Test 类 public class Test { // 可能存在异常的方法 static void test(int a){ System.out.println("传递的参数为：" + a); // 如果参数大于10，就抛出异常 if(a > 10){ try { throw new MyException(a); } catch (MyException e) { System.out.println("MyException=>" + e); } } System.out.println("OK"); } // main() 方法 public static void main(String[] args){ test(1); } } -
第二种，方法上抛出异常。
public class Test{ // 可能存在异常的方法 static void test(int a) throws MyException{ System.out.println("传递的参数为：" + a); // 如果参数大于10，就抛出异常 if(a > 10){ throw new MyException(a); // 抛出异常 } System.out.println("OK"); } // main() 方法 public static void main(String[] args){ try{ test(1); }catch(MyException e){ System.out.println("MyException=>" + e); } } } -
两种运行结果都为：
-
如果传递的参数大于10，就会抛出异常。
这里只是简单聊聊，根据不同的行业、不同的代码出现的异常也不尽相同，会根据不同情况进行不同的捕获和处理。异常类型众多，不需要马上吃透。随着时间的推移，这些异常的处理就会得心应手。
5. 总结
- 处理 运行时异常 时，采用逻辑去合理规避，同时辅助 try / catch 语句处理。
- 在多重 catch 语句块后面，可以加上一个
catch(Exception e)来处理可能会被遗漏的异常。 - 对于不确定的代码，也可以加上 try / catch 语句，来处理潜在的异常。
- 尽量去处理异常，切忌只是简单地调用
printStackTrace()去打印输出。这个printStackTrace()打印出的就是程序提示的异常信息，所以这么写没有多大意义。可以增加一些处理异常的代码，这样就能降低损失。 - 具体如何处理异常，要根据不同的业务需求和异常类型去决定。
- 尽量添加 finally 语句块去释放占用的资源。
834
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
