明确什么是异常（重点）

异常处理.pdf

异常是在程序中导致程序中断运行的一种指令流。为了保证程序出现异常之后仍然可以正确的执行完毕，所以要采用异常的处理机制。

异常体系结构

异常指的是Exception ， Exception类， 在Java中存在一个父类Throwable（可能的抛出）
Throwable存在两个子类：

  • Error：表示的是错误，是JVM发出的错误操作,只能尽量避免，无法用代码处理。
  • Exception：一般表示所有程序中的错误，所以一般在程序中将进行try…catch的处理。

图片2.png
出现 error 就是整体架构有问题，内存太小了，超出内存
受检异常 非受检异常，区别就是会不会飘红的区别。

处理异常

如果要想对异常进行处理，则必须采用标准的处理格式，处理格式语法如下：

  1. try{
  2.     // 有可能发生异常的代码段
  3. }catch(异常类型1 对象名1){//理解成if语句
  4.     // 异常的处理操作(补救措施)
  5. }catch(异常类型2 对象名2){
  7. }...
  8. finally{
  9.     // 异常的统一出口
  10. }

try+catch的处理流程

  • 一旦产生异常，则系统会自动产生一个异常类的实例化对象。
  • 那么，此时如果异常发生在try语句，则会自动找到匹配的catch语句执行，如果没有在try语句中，则会将异常抛出. 给代码调用的位置
  • 所有的catch根据方法的参数匹配异常类的实例化对象，如果匹配成功，则表示由此catch进行处理。

格式一：两种异常分开处理

  1. package com.java.demo1;
  3. import javax.swing.plaf.basic.BasicMenuUI;
  4. import java.util.InputMismatchException;
  5. import java.util.Scanner;
  7. public class Demo1 {
  8.     public static void main(String[] args) {
  9.         haha();
  10.         System.out.println("咋回来了");
  11.     }
  12.     private static void haha() {
  13.         Scanner input = new Scanner(System.in);
  14.         try {
  15.             System.out.println("请输入一个数字");
  16.             int x = input.nextInt();
  17.             System.out.println("请输入一个数字");
  18.             int y = input.nextInt();
  19.             System.out.println(x / y);
  20.         } catch (ArithmeticException e) {
  21.             System.out.println("有病");
  22.         } catch (InputMismatchException e) {
  23.             System.out.println("不行啊");
  24.         }
  25.     }
  26. }

格式二： 两种异常同时处理（了解）

  1.  private static void haha() {
  2.         Scanner input = new Scanner(System.in);
  3.         try {
  4.             System.out.println("请输入一个数字");
  5.             int x = input.nextInt();
  6.             System.out.println("请输入一个数字");
  7.             int y = input.nextInt();
  8.             System.out.println(x / y);
  9.         } catch (ArithmeticException | InputMismatchException e) {
  10.             System.out.println("有病");
  11.         } 
  12.     }

格式三（多态）

  1.  private static void haha() {
  2.         Scanner input = new Scanner(System.in);
  3.         try {
  4.             System.out.println("请输入一个数字");
  5.             int x = input.nextInt();
  6.             System.out.println("请输入一个数字");
  7.             int y = input.nextInt();
  8.             System.out.println(x / y);
  9.         } catch (Exception e) {
  10.             System.out.println("有病");
  11.         } 
  12.     }

finally

不管是否产生 了异常，最终都要执行此段代码。比如说释放内存，连接数据库，无论如何都要释放资源，所以一定要在finally中释放异常
在。。。情况下是否会执行
程序关闭了结束了，finally才不会执行，除此之外，finally必然执行。

throws

此关键字主要在方法的声明上使 用，表示方法中不处理异常，而交给调用处处理。

  1. public class Demo4 {
  2.     public static void main(String[] args) {
  4.         try {
  5.             shutdown( "");
  6.         } catch (IOException e) {
  7.             e.printStackTrace();
  8.         }
  9.     }
  11.     /**
  12.      * 
  13.      * 因为传递参数导致错误，应该将异常通过throws跑出去
  14.      * @param text
  15.      * @throws IOException 因为传递的指令不对，会导致此问题发生
  16.      */
  17.     public static void shutdown(String text) throws IOException {//参数有可能出错
  18.         Runtime.getRuntime().exec(text);
  19.     }
  20.     public static void sum(String s1, String s2){
  22.         int sum = Integer.parseInt(s1) + Integer.parseInt(s2);
  23.         System.out.println("sum");
  24.     }

throw关键字

///

  1. public void setAge(int age) {
  2.         if(age<0 || age>180){
  3.             RuntimeException e = new RuntimeException("嘿嘿傻逼");//不会导致系统产生异常
  4.             throw e;
  5.         }else{
  6.             this.age = age;
  7.         }
  8.     }

自定义异常类

异常处理常见面试题

  • try-catch-finally 中，如果 catch 中 return 了，finally 还会执行吗？

会执行！！！
执行流程： 1. 先计算返回值， 并将返回值存储起来， 等待返回
2. 执行finally代码块
3. 将之前存储的返回值， 返回出去；
注意：

  1. 返回值是在finally运算之前就确定了，并且缓存（备份）了，不管finally对该值做任何的改变，返回的值都不会改变
  2. finally代码中不建议包含return，因为程序会在上述的流程中提前退出，也就是说返回的值不是try或 catch中的值
  3. 如果在try或catch中停止了JVM,则finally不会执行.例如停电- -, 或通过如下代码退出 JVM:System.exit(0);//博客 ```java package com.java.demo1;

public class Task { public static void main(String[] args) { Person p = haha(); System.out.println(p.age); }

  1. public static Person haha(){
  2.     Person p = new Person();//在堆内存缓存的空间，里面的值可以改变
  3.     try{
  4.         p.age = 18;
  5.         return p;//备份的是地址
  6.     }catch(Exception e){ return null;}
  7.     finally {
  8.         p.age = 28;
  9.     }
  10. }
  11. static  class Person{
  12.     int age;
  13. }

} 28

package com.java.demo1;

public class Task { public static void main(String[] args) { int a = haha(); System.out.println(a); }

  1. public static int haha(){
  2.     int a = 10;
  3.     try{
  4.         return a;//备份好的a
  5.     }catch(Exception e){ return -1;}
  6.     finally {
  7.         a = 28;
  8.     }
  9. }
  10. static  class Person{
  11.     int age;
  12. }

} 10 ```

  • try-catch-finally 中哪个部分可以省略？

catch和finally可以省略其中一个 ， catch和finally不能同时省略
注意：格式上允许省略catch块, 但是发生异常时就不会捕获异常了,我们在开发中也不会这样去写代码.