JAVA进阶总结之异常

• 第一章 异常
• • 1.1 异常概念
  • 1.2 异常体系
  • 1.3 异常分类
  • 1.4 异常的产生过程解析
  • 1.5 异常的使用及执行流程
• 第二章 异常的处理
• • 2.1 抛出异常throw
  • 2.2 Objects非空判断
  • 2.3 声明异常throws
  • 2.4 捕获异常try....catch
  • 2.5 finally代码块
  • 2.6 异常注意事项
• 第三章 自定义异常
• • 3.1 概述
  • 3.2 自定义异常的练习

第一章 异常

1.1 异常概念

• 异常: 程序在运行过程中发生由于外部问题（如硬件错误、输入错误）等导致的程序异常事件。(在Java等面向对象的编程语言中）异常本身是一个对象，产生异常就是产生了一个异常对象。Java处理异常的方式是中端处理。

异常指的并不是语法错误，语法错了，编译不通过，不会产生字节码文件，根本不能运行。

1.2 异常体系

• 异常机制其实是帮助我们找到程序中的问题，异常的根类是java.lang.Throwable，其下有两个子类:java.lang.Error与java.lang.Exception，平常说的异常指java.lang.Exception。
  

Throwable体系

• Error: 严重错误Error，无法通过处理的错误，只能实现避免，好比绝症。
• Exception: 表示异常，异常产生后程序员可以通过代码的方式纠正，使程序继续运行，是必须要处理的。好比感冒，阑尾炎。

Throwable中的常用方法

• public void printStackTrace(): 打印异常的详细信息。
  包含了异常的类型，异常的原因，还包括异常出现的位置，在开发和调试阶段，都得使用printStackTrace。
• public String getMessage(): 获取发生异常的原因。
  提示给用户的时候，就提示错误原因。
• public String toString(): 获取异常的类型和异常描述信息(不用)。

1.3 异常分类

异常(Exception)的分类:

• 编译时期异常: checked异常，在编译时期就会检查，如果没有处理异常，则编译失败。(如日期格式化异常)
• 运行时期异常: runtime异常，在运行时期检查异常，在编译时期，运行异常不会编译器检测，不会报错。
  

1.4 异常的产生过程解析

• 分析异常怎么产生的，如何处理异常:

                        /*异常产生的过程*/
public class exception1 {
   public static void main(String[] args) {
             //创建int数组并赋值
       int[] arr={1,2,3};
       int e=getElement(arr,3);
       System.out.println(e);
   }
           //定义一个方法，获取指定索引处的元素
   public static int getElement(int[] arr,int index){
       int ele=arr[index];
       return ele;
   }
}

                       /*程序执行的结果*/
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
   at exception.exception1.getElement(exception1.java:12)
   at exception.exception1.main(exception1.java:7)

• 图解分析异常:
  

1.5 异常的使用及执行流程

异常的处理方案

• try…catch、try…catch…finally、try…finally
  try{
  可能会发生的异常
  }catch(异常类型 异常名(变量)){
  针对异常进行处理的代码
  }catch(异常类型 异常名(变量)){
  针对异常进行处理的代码
  }…
  [finally{
  释放资源代码；
  }]
  注意:
• catch 不能独立于 try 存在。
• catch里面不能没有内容
• 在 try/catch 后面添加 finally 块并非强制性要求的。
• try 代码后不能既没 catch 块也没 finally 块。
• try里面越少越好。
• try, catch, finally 块之间不能添加任何代码。
• finally里面的代码最终一定会执行（除了JVM退出）
• 如果程序可能存在多个异常，需要多个catch进行捕获。
• 异常如果是同级关系，catch谁前谁后没有关系
• 如果异常之间存在上下级关系，上级需要放在后面

异常的执行流程

第二章 异常的处理

Java异常处理的五个关键字: try,catch,finally,throw,throws.

• try: 用于监听。将要被监听的代码(可能抛出异常的代码)放在try语句块之内，当try语句块内发生异常时，异常就被抛出。
• catch: 用于捕获异常。catch用来捕获try语句块中发生的异常。
• final: finally语句块总是会被执行。它主要用于回收在try块里打开的物力资源(如数据库连接、网络连接和磁盘文件)。只有finally块，执行完成之后，才会回来执行try或者catch块中的return或者throw语句，如果finally中使用了return或者throw等终止方法的语句，则就不会跳回执行，直接停止。
• throw: 用于抛出异常。
• throws: 用在方法签名中，用于声明该方法可能抛出的异常。主方法上也可以使用throws抛出。如果在主方法上使用了throws抛出，就表示在主方法里面可以不用强制性进行异常处理，如果出现了异常，就交给JVM进行默认处理，则此时会导致程序中断执行。

2.1 抛出异常throw

throw关键字:

• 作用: 可以使用throw关键字在指定的方法中抛出指定的异常。
• 使用格式 throw new xxxException(“异常产生的原因”)。
• 注意:
  1.throw关键字必须写在方法的内部。
  2.throw关键字后边new的对象必须是Exception或者Exception的子类对象。
  3.throw关键字抛出指定的异常对象，我们就必须处理这个异常对象，
  （1）throw关键字后边创建的是RunTimeException或者是RunTimeException的子类对象，我们可以不处理，默认交给JVM处理(打印异常对象，中断程序)
  （2）throw关键字后边创建的是编译异常(写代码的时候报错)，我们就必须处理这个异常，要么throws，要么try…catch。

2.2 Objects非空判断

• Object类: 由静态的实用方法组成，这些方法是null-save(空指针安全的)或null-tolerant(容忍空指针的)。
• public static T requireNonNull(T obj): 查看指定引用对象不是null。

 public static <T> T requireNonNull(T obj){
        if(obj==null){
            throw new NullPointerException("空指针异常 ");
        }
        return obj;
    }

2.3 声明异常throws

• 声明异常: 将问题标识出来，报告给调用者，如果方法内通过throw抛出了编译时异常，而没有捕获处理。
• 关键字throws: 运用与方法声明之上，用于表示当前方法不处理异常，而是提醒该方法的调用者来处理异常(抛出异常)，最终交给JVM处理–>中断处理。
• 声明异常格式:

  修饰符 返回值类型 方法名(参数 throws) 异常类名1，异常类名2…{
  throw new AAAException(“产生原因”)；
  throw new BBBException(“产生原因”)；
  }

注意:

1. throws关键字必须写在方法声明处
2. throws关键字后边声明的异常必须是Exception或者是Exception的子类
3. 方法内部如果抛出了多个异常对象，那么throws后边必须也声明多个异常，如果抛出的多个异常对象有子父类关系，那么直接声明父类异常即可。
4. 调用了一个声明抛出异常的方法，我们就必须处理声明的异常，要么继续使用throws声明抛出，交给方法的调用者处理，最终交给JVM，要么try…catch自己处理异常。
5. 声明异常代码演示:

public class Throws {
    public static void main(String[] args) throws FileNotFoundException {
        read("a.txt");
    }
//如果定义功能时有问题发生需要报告给调用者，可以通过在方法上使用throws关键字进行声明
    public static void read(String path) throws FileNotFoundException {
        if (!path.equals("a.txt")) {
            //如果不是a.txt这个文件就认为该文件不存在是一个错误也就是一个异常
            throw new FileNotFoundException("文件不存在");
        }
    }
}

2.4 捕获异常try…catch

6. 如果异常出现的时候，会立刻终止程序，所以我们得处理异常:
7. 该方法不处理，而是声明抛出，由该方法的调用者来处理(throws)。
8. 在方法中使用try-catch的语句块来处理异常.
9. try-catch的方式就是捕获异常:Java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理。
10. 捕获异常语法如下:

try{
        编写可能会出现异常的代码
    }catch(异常类型 e){
        处理异常的代码
           //记录日志//打印异常信息//继续抛出异常
    }

11. Throwable类中定义的查看方法:
    1. public String getMessage():获取异常的描述信息，原因（提示给用户的时候，就提示错误原因）。
    2. public String toString():获取异常的类型和异常描述信息(不用)。
    3. public void printStackTrace():打印异常的跟踪栈信息并输出到控制台，包含了异常的类型，异常的原因，还包括异常出现的位置，在开发和调试阶段。

2.5 finally代码块

1. finally:有一些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转，导致有些语句执行不到，而final解决的就是这个问题，在finally代码块中存放的代码都是一定会执行的。
2. finally的语法: try…catch…finally:自身需要处理异常，最终还得关闭资源。finally不能单独使用。
3. finally代码块格式:

//注意:1.finally不能单独使用，必须和try一起使用.
       2.finally一般用于资源回收，无论程序是否出现异常，最后都要资源释放。
 try{
         可能产生异常的代码
    }catch(定义一个异常的变量，用来接收try中抛出异常的对象){
        异常的处理逻辑，异常对象之后，怎么处理异常对象，一般在工作中，会把异常的信息记录到一个日志中
    }
    ...
    catch(异常类名，变量名){
        
    }finally{
        无论是否出现异常都会执行
    }

2.6 异常注意事项

多异常的捕获处理

• 多个异常使用捕获又该如何处理:
  1. 多个异常分别处理。
  2. 多个异常一次捕获，多次处理(一个try多次catch).
  3. 多个异常一次捕获一次处理。

finally有return语句:如果finally有return语句，永远返回finally中的结果，避免该情况。

• 注意
  1. 运行时异常抛出可以不处理，既不捕获也不声明抛出。
  2. 如果父类抛出了多个异常，子类覆盖父类方法时，只能跑出相同的异常或者是他的子集。
  3. 父类方法没有抛出异常，子类覆盖父类方法也不可抛出异常，只能捕获处理。
  4. 在try…catch之后可以追加finally代码块，其中的代码一定会利用，通常用于资源回收。

第三章 自定义异常

3.1 概述

1. 为什么需要自定义异常:自定义异常是为了设置异常链的起点。一般情况下，我们都是允许每个程序员看到所有的异常信息，这个时候大多数都是把下一层的异常直接重掷到上一层。然而在多层次的结构中，我们有时候需要隐藏底层异常（这种异常的信息很多，很枯燥） ，而给消费者提供一个更为直观的异常，这个时候我们需要自定义异常。有的异常类jdk已经给我们提供，比如常用的IllegalArgumentException。如果你想在此再作包装，你可以创建自己的异常类。如此，消费者将以此异常作为异常链的起点。
2. 什么是自定义异常类:在开发中根据自己业务的异常情况来定义异常类.自定义一个业务逻辑异常: RegisterException,一个注册异常类。
3. 异常类如何定义:自定义一个编译期异常: 自定义类 并继承于java.lang.Exception。自定义一个运行时期的异常类:自定义类 并继承于java.lang.RuntimeException。

3.2 自定义异常的练习

要求：我们模拟注册操作，如果用户名已存在，则抛出异常并提示：亲，该用户名已经被注册。

首先定义一个登陆异常类RegisterException：

// 业务逻辑异常
public class RegisterException extends Exception {
    /**
     * 空参构造
     */
    public RegisterException() {
    }

    /**
     *
     * @param message 表示异常提示
     */
    public RegisterException(String message) {
        super(message);
    }
}

模拟登陆操作，使用数组模拟数据库中存储的数据，并提供当前注册账号是否存在方法用于判断。

public class Demo {
    // 模拟数据库中已存在账号
    private static String[] names = {"bill","hill","jill"};
   
    public static void main(String[] args) {     
        //调用方法
        try{
              // 可能出现异常的代码
            checkUsername("nill");
            System.out.println("注册成功");//如果没有异常就是注册成功，有异常就不会执行这一句
        }catch(RegisterException e){
            //处理异常
            e.printStackTrace();
        }
    }

    //判断当前注册账号是否存在
    //因为是编译期异常，又想调用者去处理 所以声明该异常
    public static boolean checkUsername(String uname) throws LoginException{
        for (String name : names) {
            if(name.equals(uname)){//如果名字在这里面 就抛出登陆异常
                throw new RegisterException("亲"+name+"已经被注册了！");
            }
        }
        return true;
    }
}

• 注意:
  1. 自定义异常类一般是exception结尾，说明该类是一个异常类。
  2. 自定义异常类，必须继承Exception或者RuntimeException
  3. 继承Exception，那么自定义的异常类就是一个编译器异常，如果方法内部抛出了编译器异常，就必须处理这个异常，要么throws，要么try…catch.
  4. 继承RuntimeException，那么自定义的异常类就是一个运行期异常，无需处理，交给虚拟机处理(中断处理)。

~喜欢的点赞关注,评论区留下宝贵的意见-谢谢呐♥♥♥~

---

*作者:Aimee.洁
*本文版权归作者和CSDN共有，欢迎转载，未经作者同意必须保留此版声明，否则保留追究法律责任的权利。

标签：Java,进阶,有图,处理,try,finally,catch,异常,public
来源： https://blog.csdn.net/weixin_52606478/article/details/115034364