异常那些事

异常

一、定义

• 异常：指的是程序在执行过程中，出现的非正常的情况，最终会导致JVM的非正常停止。

在java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出了一个异常对象。

Java处理异常的方式是中断处理。

1.异常体系

异常机制是帮助我们找到程序中的问题，异常的根类是java.lang.Throwable,其下有两个子类：

java.lang.Error与java.lang.Exception，平常所说的异常指java.lang.Exception。

Throwable中的常用方法：

• public void printStackTrace():打印异常的详细信息。
  

  包含了异常的类型，原因，位置，在开发和调试阶段，都得使用printStackTrace。

• public String getMessage():获取发生异常的原因
  

  提供给用户的时候，就提示错误原因

• public String toString():获取异常的类型和异常描述信息（不用）。
  

2.异常分类：

• Exception：编译期异常，checked异常。在编译时期，就会检查，如果没有处理异常，则编译失败。

• import java.text.ParseException;
  import java.text.SimpleDateFormat;
  import java.util.Date;
  public class Exception {
      public static void main(String[] args) throws ParseException {
          SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
          Date date = sdf.parse("1999-0909");
          System.out.println(date);
      }
  }
  
  

  上述代码运行结果为：

  Exception in thread "main" java.text.ParseException: Unparseable date: "1999-0909"
  	at java.base/java.text.DateFormat.parse(DateFormat.java:399)
  	at yichang.Exception.main(Exception.java:9)
  

• RuntimeExcepton：运行时期异常：runtime异常，在运行时期，检查异常，在编译时期

  ​ 运行异常不会编译 器检测（不报错）。

• public class RuntimeException {
      public static void main(String[] args)  {
          int[] arr = {1,2,3};
          System.out.println(arr[3]);
      }
  }
  

  上述代码运行结果为：

  Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
  	at yichang.Exception.main(Exception.java:5)
  

• Error：错误；错误

比如创建的数组的范围超过了int或其他数据类型的范围。

二、异常的产生过程解析

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

用该例子为例：

public class RuntimeException {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        int r = getele(arr, 3);
        System.out.println(r);
    }

    public static int getele(int[] arr, int a) {
        return arr[a];
    }
}

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
	at yichang.Exception.getele(Exception.java:10)
	at yichang.Exception.main(Exception.java:5)

访问了数组中3的索引，但数组没有索引3，这时JVM就会检测出程序会出现异常

JVM会做两件事：

1.JVM会根据异常产生的原因创建一个异常对象，这个异常对象包含了异常产生的（内容，原因，位置）

2.在getele方法中，没有异常的处理逻辑（try…catch)，那么JVM就会把异常对象抛出给方法的调用者main 方法来处理这个异常

main方法接收到了这个异常对象，main方法也没有异常的处理逻辑，

继续把对象抛出给main方法的调用者JVM处理

JVM接收到了这个异常对象，做了两件事

1.把异常对象（内容，原因，位置）以红色的字体打印在控制台

2.JVM会终止当前正在执行的java程序–>中断处理

三、异常的处理

1.抛出异常throw

throw关键字

作用：可以使用throw关键字在指定的方法中抛出指定的异常

使用格式：

throw new xxxException（"异常产生的原因"）

如：

public class Exception {
public static void main(String[] args) throws ArrayIndexOutOfBoundsException {
        int[] arr = {1,2,3};
        System.out.println(arr[3]);
        }
}

注：

• throw关键字必须写在方法的内部
• throw关键字后边new的对象必须是Exception或者Exception的子类对象
• throw关键字抛出指定的异常对象，我们就必须处理这个异常

​ throw关键字后边创建的是RuntimeException或者是RuntimeException的子类对象，我们可以不处理，默认交给JVM处理（打印异常对象，中断程序）

​ throw关键字后边创建的是编译异常（写代码的时候报错），我们就必须处理这个异常，要么throws，要么try…catch

以后我们首先必须对方法传递过来的参数进行合法性校验

如果参数不合法，那么我们就必须使用抛出异常的方式，告知方法的调用者，传递的参数有问题

2.Object非空判断

Object类中的静态方法

public class Exception{
	public static void main(String[] args){
		method(null);
	}
	public static void method(Object obj){
		if(obj == null)
		{
			throw new NullPointerException("传递的对象的值是null");
		}
	}
}

上述代码运行结果：

Exception in thread "main" java.lang.NullPointerException: 传递的对象的值是null
	at yichang.Exception.method(Exception.java:9)
	at yichang.Exception.main(Exception.java:4)

3.声明异常throws

**throws关键字：**异常处理的第一种方式，交给别人处理

作用：

当方法内部抛出异常对象的时候，那么我们就必须处理这个异常对象

可以使用throws关键字处理异常对象，会把异常对象声明抛出给方法的调用者处理（自己不处理，给别人处理），最终交给JVM处理–>中断处理

使用格式：

在方法声明时使用

/*修饰符 返回值类型 方法名（参数列表）*/throws XXXException，xxxException...{
	throw new XXXException("产生原因");
	throw new xxxException("产生原因");
	...
}

注意：

• throws关键字必须写在方法声明处

• throws关键字后边声明的异常必须是Exception或者是Exception的子类

• 方法内部如果抛出了多个异常对象，那么throws后边也必须声明多个异常对象

  如果抛出的多个异常对象有子父类关系，那么直接声明父类异常即可

• 调用了一个声明抛出异常的方法，我们就必须的处理声明的异常

  要么继续使用throws 声明抛出，交给方法的调用者处理，最终交给JVM

  要么try…catch自己处理异常

4.捕获异常try…catch

**try…catch：**异常处理的第二种方式，自己处理异常

格式：

try{
	//可能产生异常的代码
}catch(/*定义一个异常的变量，用来接收try中抛出的异常对象*/){
    //异常的处理逻辑，产生异常对象之后，怎么处理异常对象
    //一般在工作中，会把异常的信息记录到一个日志中
}
...
catch(/*异常类名，变量名*/){
    
}

注意：

• try中可能会抛出多个异常对象，那么就可以使用多个catch来处理这些异常对象

• 如果try中产生了异常，那么就会执行catch中的异常处理逻辑，执行完毕catch中的处理逻辑，继续执行try…catch之后的代码

  如果try中没有产生异常，那么就不会执行catch中异常的处理逻辑，执行完try中的代码，

  继续执行try…catch之后的代码

5.finally代码块

格式：

try{
	//可能产生异常的代码
}catch(/*定义一个异常的变量，用来接收try中抛出的异常对象*/){
    //异常的处理逻辑，产生异常对象之后，怎么处理异常对象
    //一般在工作中，会把异常的信息记录到一个日志中
}
...
catch(/*异常类名，变量名*/){
    
}finally{
    //无论是否出现异常都会执行
}

注意：

• finally不能单独使用，必须和try一起使用
• finally一般用于资源释放（资源回收），无论程序是否出现异常，最后都要资源释放（IO）

6.异常注意事项

• 多个异常的处理方法

1. 多个异常分别处理
2. 多个异常一次捕获，多次处理
3. 多个异常一次捕获一次处理

一般是使用一次捕获多次处理方式，格式如下：

try{
    编写可能会出现异常的代码
}catch(异常类型A，e){
    当try中出现A类型异常，就用该catch来捕获，处理异常的代码
        //记录日志/打印异常信息/继续抛出异常
}catch(异常类型B，e){
    当try中出现B类型异常，就用catch来捕获，处理异常的代码
        //记录日志/打印异常信息/继续抛出异常
}

注意：

• 运行时异常被抛出可以不处理，即不捕获也不声明抛出
• 如果finally有return语句，永远返回finally中的结果，避免该情况（finally中不要写return）
• 如果父类抛出了多个异常，子类覆盖父类方法时，只能抛出相同的异常或者是他的子集
• 父类方法没有抛出异常，子类覆盖父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出
• 在try/catch后可以追加finally代码块，其中的代码一定会被执行，通常用于资源回收

四、自定义异常类

自定义异常类：

java提供的异常类，不够使用，需要自己定义一些异常类

格式：

public class 类名 extends Exception(或RuntimeException){
	添加一个空参构造方法
	添加一个带异常信息的构造方法
}

注意：

• 自定义异常类一般都是以Exception结尾，说明该类是一个异常类

• 自定义异常类，必须继承Exception或者RuntimeException

  继承Exception：那么自定义的异常类就是一个编译期异常，如果方法内部抛出了编译期异常，就必须处理这 个异常，要么throws，要么try…catch

用于资源回收

四、自定义异常类

自定义异常类：

java提供的异常类，不够使用，需要自己定义一些异常类

格式：

public class 类名 extends Exception(或RuntimeException){
	添加一个空参构造方法
	添加一个带异常信息的构造方法
}

注意：

• 自定义异常类一般都是以Exception结尾，说明该类是一个异常类

• 自定义异常类，必须继承Exception或者RuntimeException

  继承Exception：那么自定义的异常类就是一个编译期异常，如果方法内部抛出了编译期异常，就必须处理这 个异常，要么throws，要么try…catch

  继承RuntimeException：那么自定义的异常类就是一个运行期异常，无需处理，交给JVM处理（中断处理）