Java异常
Java异常
- 异常概念
-
- 举几个我们常见的例子：
- 异常的体系结构
- 异常的分类
- 异常的抛出 throw
- 异常的处理
-
- 使用throws注意事项
- try ... catch 捕获并处理
- 获取异常信息
- 关于finally
- 自定义异常
异常概念
就像人会生病一样，人生病就会产生异常行为，比如感冒发烧等，同样的，当程序出错的时候，程序执行过程中也会发生的不正常行为。
在Java中，将程序执行过程中发生的不正常行为称为异常。
举几个我们常见的例子：
- 算术异常：
System.out.println(10 / 0); //在我们数学中，0是不能做被除数数的，这里也一样
当我们输入这段代码并执行时，会产生如下结果：
2. 数组越界异常：
就是数组越界访问抛出的异常：
int[] arr = {1, 2, 3, 4};
System.out.println(arr[4]); //数组元素下标最大为3，没有4
结果：
3. 空指针异常：
int[] arr = null;
System.out.println(arr.length);
我们以后见到最多的应该就是空指针异常和数组越界异常了。
我们可以看出，对于不同类型的异常，都有与其对应的类来进描述。
异常的体系结构
大致如下：
- Throwable：是异常体系的顶层类，其派生出两个重要的子类, Error 和 Exception
- Error：指的是Java虚拟机无法解决的严重问题，比如：JVM的内部错误、资源耗尽等，典型代表：StackOverflowError和OutOfMemoryError，一旦发生回天乏术。
- Exception：异常产生后程序员可以通过代码进行处理，使程序继续执行。比如：感冒、发烧。我们平时所说的异常就是Exception。
异常的分类
也就是图中Exception派生出的子类，图中的受查异常与非受查异常是什么意思呢？
异常可能在编译时发生，也可能在程序运行时发生，根据发生的时机不同，可以将异常分为：受查异常与非受查异常。
在程序编译期间发生的异常，称为编译时异常，也称为受查异常。
编译时异常是表示必须在编写程序的时候预先对这种异常进行处理，如果不处理编译器就报错。编译时异常发生概率较高。
这里我们调用Object的clone方法报错了，是因为没有预先处理异常，如下即可：
在程序执行期间发生的异常，称为运行时异常，也称为非受查异常
RunTimeException以及其子类对应的异常，都称为运行时异常。比如：NullPointerException、ArrayIndexOutOfBoundsException、ArithmeticException。
注：编译时出现的语法性错误，不能称之为异常，这是 “编译期” 出错。而运行时指的是程序已经编译通过得到 class 文件了, 再由 JVM 执行过程中出现的错误。
异常的抛出 throw
Java中，可以借助throw关键字，抛出一个指定的异常对象，将错误信息告知给调用者。具体语法如下：
throw new XXXException("异常产生的原因");
举个简单例子：已知数组下标，求该下标的元素。
public class Test {
public static int getElement(int[] array, int index){
if(null == array) {
throw new NullPointerException("传递的数组为null");
} if(index < 0 || index >= array.length){
throw new ArrayIndexOutOfBoundsException("传递的数组下标越界");
}
return array[index];
}
public static void main(String[] args) {
int[] array = {1,2,3};
getElement(array, 3);
}
}
注意几点：
- throw必须写在方法体内部
- 抛出的对象必须是Exception 或者 Exception 的子类对象
- 如果抛出的是 RunTimeException 或者 RunTimeException 的子类,也就是非受查异常，则可以不用处理，直接交给JVM来处理
- 如果抛出的是编译时异常，用户必须处理，否则无法通过编译
- 异常一旦抛出，其后的代码就不会执行
异常的处理
异常的出理方式主要有两种：异常声明throws 以及 try-catch捕获处理。
格式：
修饰符 返回值类型 方法名(参数列表) throws 异常类型1，异常类型2...{
}
我们可以看到，一个方法可以声明多个异常，那为什么要声明异常呢？
当方法中抛出编译时异常，用户不想处理该异常，此时就可以借助throws将异常抛给方法的调用者来处理。即当前方法不处理异常，提醒方法的调用者处理异常。
public class Test {
public static void func() throws ClassNotFoundException {
//throws ClassNotFoundException 该声明表示该方法在执行过程中可能会出现该异常
//属于编译时异常
System.out.println("func!");
}
public static void main(String[] args) {
func(); //这里报红，这里func方法将它的异常抛给了main方法，
//所以main方法必须对其进行处理，不处理编译器就报错
}
}
怎么解决呢？我们有两种方法：
方法一：throws抛给给调用者（谁调用了，谁处理，调用者知道是什么异常）
public class Test {
public static void func() throws ClassNotFoundException {
System.out.println("func!");
}
public static void main(String[] args) throws ClassNotFoundException {
//这里将异常抛给了main函数的调用者JVM，让JVM来处理异常
func();
}
}
JVM处理结果就是程序中断，抛出该异常对象，本质上并没有对异常进行处理，而下面的方法就是对其进行处理。
方法二：try…catch 捕捉处理（调用者不知道是什么异常）
public class Test {
public static void main(String[] args) {
try {
func(); //可能出现异常的代码
} catch (ClassNotFoundException e) { //对该异常进行捕捉
e.printStackTrace(); //处理该异常
}
}
public static void func() throws ClassNotFoundException {
System.out.println("func!");
}
}
使用throws注意事项
- throws必须跟在方法的参数列表之后
- 声明的异常必须是 Exception 或者 Exception 的子类
- 方法内部如果抛出了多个异常，throws之后必须跟多个异常类型，之间用逗号隔开，如果抛出多个异常类型具有父子关系，直接声明父类即可。
- 调用声明抛出异常的方法时，调用者必须对该异常进行处理，或者继续使用throws抛出
try … catch 捕获并处理
举个栗子：
public static void main(String[] args) {
try {
func(null); //如果这里发生异常，那么就看下面的catch是否能捕获异常，
//如果未发生异常，则跳过catch
} catch (CloneNotSupportedException e) {
//如果catch里捕获的异常类型与try里抛出的异常类型相同，则该异常被捕获，然后程序进入该catch里
System.out.println("捕获到了 CloneNotSupportedException 异常");
} //catch(异常类型 e){
//如果可能程序出现多个异常，则多加几个catch语句捕获异常
// 对异常进行处理
//}finally{
// 此处代码一定会被执行到,无论是否发生异常
//}
//程序处理完异常后就执行正常代码
System.out.println("正常逻辑");
}
public static void func(int[] array) throws CloneNotSupportedException {
if(array == null) {
throw new CloneNotSupportedException();
}
}
输出：
总结：
- try块内抛出异常位置之后的代码将不会被执行
- 如果抛出异常类型与catch时异常类型不匹配，即异常不会被成功捕获，也就不会被处理，继续往外抛，直到JVM收到后中断程序----异常是按照类型来捕获的。
- try中可能会抛出多个不同的异常对象，则必须用多个catch来捕获----即多种异常，多次捕获。如果异常之间具有父子关系，一定是子类异常在前catch，父类异常在后catch
- 可以通过一个catch捕获所有的异常，即多个异常，一次捕获(不推荐)
由于 Exception 类是所有异常类的父类. 因此可以用这个类型表示捕捉所有异常.
获取异常信息
在catch 语句里我们有三种处理方法，以上述代码为例：
public static void main(String[] args) {
try {
func(null);
} catch (CloneNotSupportedException e) {
// 异常的处理方式
//System.out.println(e.getMessage()); // 只打印异常信息
//System.out.println(e); // 打印异常类型，异常信息
e.printStackTrace(); // 打印信息最全面
}
System.out.println("正常逻辑");
}
public static void func(int[] array) throws CloneNotSupportedException {
if(array == null) {
throw new CloneNotSupportedException();
}
}
关于finally
有些特定的代码，不论程序是否发生异常，都需要执行，比如程序中打开的资源：网络连接、数据库连接、IO流等，在程序正常或者异常退出时，必须要对资源进进行回收。另外，因为异常会引发程序的跳转，可能导致有些语句执行不到，finally就是用来解决这个问题的。
try{
// 可能会发生异常的代码
}catch(异常类型 e){
// 对捕获到的异常进行处理
}finally{
// 此处的语句无论是否发生异常，都会被执行到
}
自定义异常
系统定义的异常主要是用来处理一些常见的运行错误，对于某端代码自己的特有错误，需要程序员自己来创建自己的异常类，来处理。
实现方式：
- 自定义异常类，然后继承自Exception 或者 RunTimeException
- 实现一个带有String类型参数的构造方法，参数含义：出现异常的原因
注意：
自定义异常通常会继承自 Exception 或者 RuntimeException
继承自 Exception 的异常默认是受查异常
继承自 RuntimeException 的异常默认是非受查异常
举个例子，实现一个用户登录功能：
public class Test {
public static void fun(String name2, String code2) throws PasswordException, UsernameException {
String name = "张三";
String code = "666666";
if(!name2.equals(name)) { //如果输入的姓名或密码错误，则抛出异常
throw new PasswordException("用户名错误!");
}
if(!code2.equals(code)) {
throw new UsernameException("密码错误！");
}
System.out.println("输入成功！！！");
}
public static void main(String[] args) throws PasswordException, UsernameException {
Scanner scanner = new Scanner(System.in);
String name = scanner.nextLine();
String code = scanner.nextLine();
fun(name,code);
}
}
public class PasswordException extends Exception{
public PasswordException(String message) {
super(message);
}
}
public class UsernameException extends Exception{
public UsernameException(String message) {
super(message);
}
}