【异常----finally和自定义异常】

---

finally

有些特定的代码，不论程序是否发生异常，都需要执行，比如程序中打开的资源：在程序正常或者异常退出时，必须要对资源进进行回收。另外，因为异常会引发程序的跳转，可能导致有些语句执行不到，finally就是用来解决这个问题的。

语法格式：

try{
// 可能会发生异常的代码
}catch(异常类型 e){
// 对捕获到的异常进行处理
}finally{
// 此处的语句无论是否发生异常，都会被执行到
}
// 如果没有抛出异常，或者异常被捕获处理了，这里的代码也会执行

public static void main(String[] args) {
try{
int[] arr = {1,2,3};
arr[100] = 10;
arr[0] = 10;
}catch (ArrayIndexOutOfBoundsException e){
System.out.println(e);
}finally {
System.out.println("finally中的代码一定会执行");
}
System.out.println("如果没有抛出异常，或者异常被处理了，try-catch后的代码也会执行");
}

那为什么还要finally？

因为有一种情况是：进入try语句之后，报了异常，又进入catch语句，然后又进入finally语句，最后在try语句遇到return返回。导致try-catch-finally之后的代码根本就没有执行，会造成资源泄漏。
所以：finally中的代码一定会执行的，一般在finally中进行一些资源清理的扫尾工作。

public class Test {
   public static int getData(){
      Scanner sc = null;
      try{
         sc = new Scanner(System.in);
         int data = sc.nextInt();
         return data;
      }catch (InputMismatchException e){
         e.printStackTrace();
      }finally {
         System.out.println("finally中代码");
      }
      System.out.println("try-catch-finally之后代码");
      if(null != sc){
         sc.close();
      }
      return 0;
   }

   public static void main(String[] args) {
      int data = getData();
      System.out.println(data);
   }
}

练习

// 下面程序输出什么？
public static void main(String[] args) {
System.out.println(func());
}
public static int func() {
try {
return 10;
} finally {
return 20;
}
}
A: 10 B: 20 C: 30 D: 编译失败
//答案是B

finally 的执行，先执行finally才执行方法(try 或者 catch 中如果有 return ). 但是如果finally 中也存在 return 语句, 那么就会执行 finally 中的 return, 从而不会执行到 try 中原有的 return。
所以不建议在 finally 中写 return

问题

1. throw 和 throws 的区别？
   答： throw 用来扔出异常， throws用来在方法定义时声明异常
2. finally中的语句一定会执行吗？
   答：一定会

异常的处理流程

如果本方法中没有合适的处理异常的方式, 就会沿着调用栈向上传递。
如果向上一直传递都没有合适的方法处理异常, 最终就会交给 JVM 处理, 程序就会异常终止。

public static void main(String[] args) {
func();
System.out.println("after try catch");
}
public static void func() {
int[] arr = {1, 2, 3};
System.out.println(arr[100]);
}

程序已经异常终止了, 没有执行到 System.out.println(“after try catch”); 这一行。

【异常处理流程总结】

1. 程序先执行 try 中的代码
2. 如果 try 中的代码出现异常, 就会结束 try 中的代码, 看和 catch中的异常类型是否匹配.
3. 如果找到匹配的异常类型, 就会执行 catch 中的代码
4. 如果没有找到匹配的异常类型,就会将异常向上传递到上层调用者.
5. 无论是否找到匹配的异常类型, finally 中的代码都会被执行到(在该方法结束之前执行).
6. 如果上层调用者也没有处理的了异常, 就继续向上传递.
7. 一直到 main 方法也没有合适的代码处理异常, 就会交给 JVM 来进行处理,
   此时程序就会异常终止.

自定义异常类

有些异常类无法满足要求，所以可以自己实现自定义异常类

//实现一个用户登陆功能.

具体方式：
1.自定义异常类，然后继承自Exception 或者 RunTimeException
2.实现一个带有String类型参数的构造方法，参数含义：出现异常的原因

public class LogIn {
   private String userName = "admin";
   private String password = "123456";
   
public static void loginInfo(String userName, String password)throws UserNameException,PasswordException{
     if (!userName.equals(userName)) {
       throw new UserNameException("用户名错误！");
  }
     if (!password.equals(password)) {
       throw new PasswordException("用户名错误！");
  }
       System.out.println("登陆成功");
  }
public static void main(String[] args) {
     try {
     loginInfo("admin", "123456");
     } catch (UserNameException e) {
     e.printStackTrace();
     } catch (PasswordException e) {
     e.printStackTrace();
     }
}
}

class UserNameException extends Exception {
    public UserNameException(String message) {
      super(message);
    }
}
class PasswordException extends Exception {
    public PasswordException(String message) {
      super(message);
    }
}

注意事项
自定义异常通常会继承自 Exception 或者 RuntimeException
继承自 Exception的异常默认是受查异常
继承自 RuntimeException 的异常默认是非受查异常