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

13 异常

13.1 异常概念

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

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

异常体系

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

• Throwable体系

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

• Exception异常分类

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

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

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

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


• 演示&＃xff1a;错误和异常【编译和运行】时

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


13.2 异常的产生过程解析

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

13.3 异常的阐释和处理

13.3.1 throw关键字

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

语法格式

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


• 需求&＃xff1a;提供一个Person类&＃xff0c;在Person下提供2个子类Man和Woman&＃xff0c;在提供一个类&＃xff0c;这个类负责通过参数创建对应类的对象操作

  //抽象父类 ---> Person
public abstract class Person {
private String name;
private String sex;
public Person(){}
public Person(String name, String sex) {
this.name &＃61; name;
this.sex &＃61; sex;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name &＃61; name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex &＃61; 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("没有这个性别&＃xff0c;无法创建....");
}
}
}
class Test{
public static void main(String[] args) {
Person man &＃61; FactoryPerson.createPerson("男人");
System.out.println(man.getSex());
Person oldMan &＃61; FactoryPerson.createPerson("老人");
System.out.println(oldMan.getSex());
}
}


13.3.2 throws关键字

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

PS:throws关键字只能在方法声明的位置使用即小括号后

访问权限修饰符 [其他修饰符] 返回值类型 方法名(参数列表)throws 异常类名1,异常类名2...{
方法体
return 或 throw 关键字
}
PS&＃xff1a;throws 关键字后面的异常可以有多个&＃xff0c;每个异常之间使用[,]分隔


• 需求&＃xff1a;使用日起格式化类&＃xff0c;解析字符串到Date对象

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


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

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

13.3.3 try-catch代码块

​ 捕获处理异常try…catch

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

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

语法格式

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


​ 注意&＃xff1a;

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

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

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

演示&＃xff1a;

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


​ 总结&＃xff1a;

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

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

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

13.3.4 try-catch-finally代码块

​ finally语句代码快

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

语法格式

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


演示&＃xff1a;

import java.text.SimpleDateFormat;
import java.util.Date;
public class TryCatchFinallyDemo {
public static void main(String[] args) {
try {
int[] arr &＃61; new int[1];
//让代码出现异常
System.out.println(arr[2]);
//System.out.println(arr[0]);
SimpleDateFormat sdf &＃61; new SimpleDateFormat("yyyy-MM-dd");
Date parse &＃61; 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相似点和区别

• 相似点&＃xff1a;除了长得像没有任何相似

• 区别点&＃xff1a;

  
  

  • final是一个修饰主要用于修饰类、方法、常量&＃xff0c;表示最终的无法修改的&＃xff0c;

  • finally是捕获异常是所处理代码块&＃xff0c;主要作用是无论异常是否发生都会执行代码块&＃xff0c;可以用于保证长连接资源释放&＃xff0c;

  • finalize是Object类中所提供一个方法&＃xff0c;这个方法无需程序调用&＃xff0c;调用这个方法是GC&＃xff0c;当GC回收资源对象时会默认调用finalize进行收尾操作

13.3.5 自定义异常

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

例如&＃xff1a; 注册信息异常 —> RegisterException 胖了异常 —> PangExcetption

如果来定义自定义异常&＃xff1a;

PS&＃xff1a;在提供自定义异常时&＃xff0c;你要明确原则是你要提供异常来使用【编译时异常还是运行时异常】

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

//自定义的注册异常
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 &＃61; {"zhangsan","lisi","wangwu"};
public static void main(String[] args) {
Scanner input &＃61; new Scanner(System.in);
System.out.println("请输入用户名&＃xff1a;");
String username &＃61; 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("不好意思&＃xff1a;"&＃43;username&＃43;"已经存在无法注
册");
}
}
return true;
}
}