13 Java异常（异常过程解析、throw、throws、try-catch关键字）

文章目录

- - 13 异常
  - - 13.1 异常概念
    - 13.2 异常的产生过程解析
    - 13.3 异常的阐释和处理
    - - 13.3.1 throw关键字
      - 13.3.2 throws关键字
      - 13.3.3 try-catch代码块
      - 13.3.4 try-catch-finally代码块
      - Java中final、finally和finalize相似点和区别
      - 13.3.5 自定义异常

13 异常

13.1 异常概念

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

PS：在Java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出一
个异常对象，Java处理异常的方式是中断处理【终止程序的运行】，还有异常指的并不是语法错
误，语法错了，编译时不会通过，不会产生字节码文件，根本不能运行

异常体系

异常机制其实是帮组我们找到程序中问题，异常的根类的是java.lang.Throwable,其下有两个子
类：java.lang.Error和java.lang.Exception,平时在说的程序异常其实是指java.lang.Excetption

请添加图片描述

Throwable体系
- Error:严重的错误，无法通过处理的错误，只能事先避免【这就好比现实生活中“绝症”】
- Exception:表示异常，异常产生后程序员是可以通过代码的方式进行纠正，使程序继续执行，是必要的处理。【这就好比现实生活中“感冒”】
Exception异常分类

我们平时代码所说的异常其实就是指Exception，因为这类异常一旦出现，我们就要对代码进行更
正和修复程序

编译时异常：checked异常，在编译时期，就会进行检查，如果没有处理异常，则编译失败，造成程序是无法正确运行的【比如：日期格式化类中解析方法】

运行时异常：runtime异常，在运行时期，检查异常，在编译时期，运行时异常不会编译器所检测（提示错误信息），只有当程序运行起来之后才会出现异常【比如：数组下标越界异常】

请添加图片描述

**在Java中编译时异常体现在于父类Exception，Java中运行时异常父类是RuntimeException，编译时异常是包含运行时异常即RuntimeException是Exception子类**

演示：错误和异常【编译和运行】时

  public class ThrowableDemo {
      public static void main(String[] args) throws ParseException {
          //错误Error --》 死递归（访问无限调用自身，不能停止）【栈溢出错误】
          //java.lang.StackOverflowError ---》 栈溢出错误
          //show();
          //异常Exception --》
          // 运行时异常 ---> 数组下标越界异常 ---> ArrayIndexOutOfBoundsException
  //          int[] arr = new int[2];
  //           System.out.println(arr[3]);
          /*
          编译时异常 ---> 时间格式化解析方法 Unhandled exception: XXXXX ---> 提示是一个编译时异常需要处理
          java: 未报告的异常错误java.text.ParseException; 必须对其进行捕获或声明以便抛出
          编译时异常发现时，必须进行处理，否则无法正确执行代码
          */
          SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
          sdf.parse("1990-01-01");
      }
      public static void show(){
          show();
      }
  }

13.2 异常的产生过程解析

编写一个程序，程序会产生一个数组下标越界异常，分析以下异常的过程

请添加图片描述

13.3 异常的阐释和处理

13.3.1 throw关键字

在Java中，提供了一个throw关键字，它的作用可以抛出一个指定异常对象，throw关键字主要使用在方法的内部，用来抛出一个异常对象，将这个异常对象传递给方法的调用者，并结束方法的执行
PS：因为throw关键字在刚刚描述中说道了“结束方法执行”，所以throw可以当做一次return操作使用，return关键字作用“结束方法执行”，只不过throw返回是异常对象，return返回的是数据，在实际开发中，如果return已将将所有条件结果都进行了返回，但是方法依旧提示缺少一个return，此时就可以在最终的位置提供一个throw抛出一个异常

语法格式
throw new 异常类名(异常信息);
PS：异常名可以使用系统定义好的异常名，也可以使用自定义异常，异常信息是一个String字符串即
异常是因为什么原因出现的
例如：
throw new NullPointerException("因为数组arr引用为null，所以出现异常");
或者 --》在使用throw 抛出异常信息时最常用异常类型
throw new RuntimeException("程序运行时出错，某些数据没有初始化");

需求：提供一个Person类，在Person下提供2个子类Man和Woman，在提供一个类，这个类负责通过参数创建对应类的对象操作

//抽象父类 ---> Person
public abstract class Person {
    private String name;
    private String sex;
    public Person(){}
    public Person(String name, String sex) {
        this.name = name;
        this.sex = sex;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
}
class Man extends Person{
    public Man() {
    }
    public Man(String name, String sex) {
        super(name, sex);
    }
}
class Woman extends Person{
    public Woman() {
    }
    public Woman(String name, String sex) {
        super(name, sex);
    }
}
class FactoryPerson{
    public static Person createPerson(String sex){
        switch (sex){
            case "男人":
                return new Man();
            case "女人":
                return new Woman();
            default:
//throw 可以当做一个return使用
                throw new RuntimeException("没有这个性别，无法创建....");
        }
    }
}
class Test{
    public static void main(String[] args) {
        Person man = FactoryPerson.createPerson("男人");
        System.out.println(man.getSex());
        Person oldMan = FactoryPerson.createPerson("老人");
        System.out.println(oldMan.getSex());
    }
}

13.3.2 throws关键字

throws关键字的作用声明处理异常：使用throws关键字将异常信息标识出来，表示的当前方法不处理异常，而是提醒给调用方法者，让调用方法这来处理这个异常，如果调用方法这也不处理这异常，可以继续使用throws向上声明标识异常，直到遇到main方法还不处理，最终这个异常会被JVM虚拟所捕获处理，JVM处理方式就是停止JVM虚拟机，打印异常栈信息

PS:throws关键字只能在方法声明的位置使用即小括号后
访问权限修饰符 [其他修饰符] 返回值类型 方法名(参数列表)throws 异常类名1,异常类名2...{
        方法体
        return 或 throw 关键字
        }
PS：throws 关键字后面的异常可以有多个，每个异常之间使用[,]分隔

需求：使用日起格式化类，解析字符串到Date对象

public class ParseExceptionDemo {
    //此时异常声明标识是在main方法上，如果一旦触发异常必然是JVM虚拟停止并打印异常信息
    public static void main(String[] args) throws ParseException, IOException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String time = "1990-01-01";
        Date parse = sdf.parse(time);
        //因为在show方法上声明标识了一个编译时异常IOException，所以只要调用show方法就需要
        处理这个异常
        show();
    }
    public static void show()throws IOException{
        //Unhandled exception: java.io.IOException-->因为IOException是编译异常
        //需要外界调用按方法时，知晓这个内部会出现异常问题
        throw new IOException();
    }
}

总结：之所以会有异常产生是因为，方法体的内部使用throw关键字创建一个异常对象，抛出给调用者所以会产生异常，产生了异常之后可以使用throws关键字将这个异常声明标识，谁调用谁处理这个异常，这种方式也是开发中经常使用一种方式

PS：尽量不要在main方法中声明标识异常，因为这样处理化就是JVM虚拟机，处理方式就是停止JVM虚拟机，打印异常信息所以我们尽量不要这样操作【虽然在开中都是这样做的】

13.3.3 try-catch代码块

捕获处理异常try…catch

当程序出现异常时，JVM处理方式是终止程序，打印【异常栈信息】，只要代码中出现异常时，异常后续提供代码是无法正常执行，所以除了throws声明标识异常信息之外， Java中还一种处理异常的方式，这种方式叫做【捕获处理异常】

捕获处理异常:对异常进行捕获处理，处理完成完成之后可以正常向下执行

语法格式
try{
编写代码，这里的代码是可能出现异常代码
}catch(异常类型 e){
提供当前处理异常代码
例如"【记录日志、打印异常信息、继续抛出异常等等】"
}
执行步骤：
1. 首先会先执行try代码块中代码，如果try代码块中代码出现了异常，那么就执行catch代码
块中代码，执行完毕之后，程序继续向下执行
2. 如果try代码块中代码没有出现异常，那么就不会执行catch代码块中代码，而是代码继续向
后执行

注意：

try和catch都不能单独使用，必须连用
catch后面提供小括号内，是当前要捕获的异常类型即try代码块中可能会出现异常类型

使用e即形成(异常类型 e)声明形式，相当于是创建了一个异常类型的对象e，e这个对象就代表这个异常类型，可以在catch代码块中使用

try代码块中出现了异常，那么出现异常位置后面的代码都不会在执行了，而是转而执行catch代码块
catch代码块是可以根据try中可能出现异常进行添加的，根据出现异常追加catch代码块，但是有一个原则，父类异常一定要放置到最后一个catch中，之前都应该是子类异常，如果将父类异常放置到第一个catch中，后续catch代码块都无法进行正常捕获操作【即父类异常将所有异常都接收了就会造成子类无法接收异常】

演示：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class TryCatchDemo {
    public static void main(String[] args) {
    //提供出现异常代码
/*
int[] arr = new int[1];
System.out.println(arr[2]);//arr[2]出现了下标越界异常，没回造成当前后续代码无法
执行
System.out.println("我要是出现，证明程序执行到这行代码....");
*/
//提供try...catch代码块进行一个捕获处理 -->快捷键 ctrl+atl+t
/* try {
int[] arr = new int[1];
System.out.println(arr[2]);//arr[2]出现了下标越界异常，没回造成当前后续代码
无法执行
} catch (ArrayIndexOutOfBoundsException e) { //catch后面小括号内提供异常类
型，尽量是要对应捕获的异常类型
//提供除以异常方式
*//*
catch中确实可以做异常信息的提示，保证代码可以继续向后执行，但是只要出现以异常信
息
说明比代码出现了问题，虽然catch提供错误信息让代码继续执行，但并没有修改错误异常
代码
当我们发现出现异常信息时，需要及时的处理当前try中产生产生异常代码，否则虽然保证
代码正常执行，但是效果是错误的
*//*
//System.out.println("下标越界了，无法访问");
*//*
Throwable类中还提供一些方法可以方便不我们在catch代码块中进行错误信息的提示
getMessage() --> 打印异常信息【这个信息是系统提供（可能会很笼统）】
*//*
//System.out.println(e.getMessage());
*//*
开发阶段可以使用这个方法，但是项目上线之后就建议修改掉这个操作
方法printStackTrace() --> 打印异常栈信息包含了：【异常类型、异常原因、异常出
现位置】
*//*
e.printStackTrace();
}
System.out.println("我要是出现，证明程序执行到这行代码....");*/
        try {
            int[] arr = new int[1];
            System.out.println(arr[2]);//try代码块中如果代码出现异常，后续代码都无法执行【try中】
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            Date parse = sdf.parse("1990-10-10");
            System.out.println(parse);
        } catch (ParseException e) {
            e.printStackTrace();
        } catch (ArrayIndexOutOfBoundsException e){//try多个异常是，添加多个catch代码块进行异常追加捕获操作
            e.printStackTrace();
        }
        //提供多个catch的时候父类异常一定要在最后一个catch中，不要放置到之前否则无法正常捕获异常【异常子类】
        System.out.println("我被还行了");
        //ps: 在开发中如何处理多个catch的问题？因为代码中如果异常过多，那么会造成代码中catch语句非常多
        // 代码的简洁基本上就没有，所以面临这种多个异常需要处理是，就是直接提供父类异常抓取
        try {
            int[] arr = new int[1];
            System.out.println(arr[2]);//try代码块中如果代码出现异常，后续代码都无法执行【try中】
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            Date parse = sdf.parse("1990-10-10");
            System.out.println(parse);
        } catch (Exception e) { //这个父类Exception的原则就是谁出现异常就抓取谁吗，而且都可以匹配
            e.printStackTrace();
        }
        //提供多个catch的时候父类异常一定要在最后一个catch中，不要放置到之前否则无法正常捕获异常【异常子类】
        System.out.println("我被换行了");
    }
}

总结：

捕获异常处理，如果程序出现了异常，保证程序可以继续向后执行
声明标识异常，如果程序出现了异常，程序就不会继续向后执行了

Java中异常机制的目的是为了提示开发人员，出现异常是代码出现问题需要进行修改，所以建议在编码阶段可以使用throws进行处理，在程序上线之后建议将出现异常位置使用try…catch方式进行处理这样可以保证对用户友好提示。

try…catch捕获异常之后，是对异常可以进行二次处理信息提示，但是只是提示了异常问题，不会对异常继续修改，所以开发时看到异常信息一定要修改代码才可以，才能保证保证正确执行

13.3.4 try-catch-finally代码块

finally语句代码快

finally语句代码块是配合try…catch语句代码块执行，finally语句代码块有一个特点，特点是无论是否发生异常，finally语句代码块【必然执行】，所以利用finally语句代码块的特点可以进行一些资源释放的操作【TCP/UDP网络连接、IO流文件的处理、JDBC进行数据库连接操作等等】

语法格式
try{
编写代码，这里的代码是可能出现异常代码
}catch(异常类型 e){
提供当前处理异常代码
例如"【记录日志、打印异常信息、继续抛出异常等等】"
}finally{
无论发生异常与否，这里都会执行
}
执行步骤：
	1. 首先会先执行try代码块中代码，如果try代码块中代码出现了异常，那么就执行catch代码
块中代码执行完毕之后，而是执行finally语句代码块中代码，然后程序继续向下执行
	2. 如果try代码块中代码没有出现异常，那么就不会执行catch代码块中代码，但是会执行
finally语句代码块中代码，然后程序继续向下执行
"ps: finally语句代码块不能单独使用"

演示：

import java.text.SimpleDateFormat;
import java.util.Date;

public class TryCatchFinallyDemo {
    public static void main(String[] args) {
        try {
            int[] arr = new int[1];
            //让代码出现异常
            System.out.println(arr[2]);
            //System.out.println(arr[0]);
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            Date parse = sdf.parse("1990-10-10");
            System.out.println(parse);
            //return; //---> 提供一个return关键字让方法结束 --》 return是不会阻止
            finally与就块执行
             // System.exit(1);---> 终止虚拟机 所以finally遇到它时候是不会执行
        } catch (Exception e) {
             // System.exit(1);
            e.printStackTrace();
        }finally {
            // 所以利用finally代码块进行资源释放
            System.out.println("无论是否发生异常finally都将执行");
        }
        System.out.println("我换行行了");
    }
}

Java中final、finally和finalize相似点和区别

相似点：除了长得像没有任何相似
区别点：
- final是一个修饰主要用于修饰类、方法、常量，表示最终的无法修改的，
- finally是捕获异常是所处理代码块，主要作用是无论异常是否发生都会执行代码块，可以用于保证长连接资源释放，
- finalize是Object类中所提供一个方法，这个方法无需程序调用，调用这个方法是GC，当GC回收资源对象时会默认调用finalize进行收尾操作

13.3.5 自定义异常

Java中是提供了很多异常类类型，共开发者在程序中进行异常类型使用，但是Java中所定义的异常类型在某些时候，还是无法满足开发需求，根据自身开发业务逻辑自行定义异常，此时自定义异常就出现了

例如：注册信息异常 —> RegisterException 胖了异常 —> PangExcetption

如果来定义自定义异常：

PS：在提供自定义异常时，你要明确原则是你要提供异常来使用【编译时异常还是运行时异常】

如果提供是自定义编译时异常: 只需要将自定义异常类继承与java.lang.Exception即可
如果提供是自定义运行时异常:只需要将自定义异常类继承与java.lang.RuntimeException即可
类中无需提供任何其他操作，只要仿照父类生成构造就可以了

//自定义的注册异常
public class RegisterException extends RuntimeException{
    //精简化只提供无参和一个参数为String message的有参构造方法即可
    //其他都可以提供
    public RegisterException() {
    }
    public RegisterException(String message) {
        super(message);
    }
    public RegisterException(String message, Throwable cause) {
        super(message, cause);
    }
    public RegisterException(Throwable cause) {
        super(cause);
    }
    public RegisterException(String message, Throwable cause, boolean
            enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}
import java.util.Scanner;
public class Test3 {
    //在当前类中提供一个账号名数组
    private static String[] usernames = {"zhangsan","lisi","wangwu"};
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入用户名：");
        String username = input.next();
        try {
            if (checkUserName(username)){
                System.out.println("注册成功");
            }
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
    public static boolean checkUserName(String username){
        for(String name : usernames){
            if (name.equalsIgnoreCase(username)){
                throw new RegisterException("不好意思："+username+"已经存在无法注
                        册");
            }
        }
        return true;
    }
}