Java之异常

概述

异常是什么？

异常是代码在编译或者执行的过程中可能出现的错误

异常分为几类？

1. 编译时异常、运行时异常。

2. 编译时异常:没有继承RuntimeExcpetion的异常，编译阶段就会出错。

3. 运行时异常:继承自RuntimeException的异常或其子类，编译阶段不报错，运行可能报错。

学习异常的目的？

避免异常的出现，同时处理可能出现的异常，让代码更稳健。

运行时异常

直接继承自RuntimeException或者其子类，编译阶段不会报错，运行时可能出现的错误。

一般是指程序员业务没有考虑好或者是编程逻辑不严谨引起的错误。

事例

1. 数组索引越界异常:ArraylndexOutofBoundsException

2. 空指针异常:NullPointerException，直接输出没有问题，但是调用空指针的变量的功能就会报错

3. 数学操作异常: ArithmeticException

4. 类型转换异常: ClassCastException

5. 数字转换异常: NumberFormatException

编译时异常

不是RuntimeException或者其子类的异常，编译阶就报错，必须处理，否则代码不通过

示例

 String date = "2015-01-12 14:27:56";
 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 Date d = sdf.parse(date); //日期解析异常
 System.out.println(d);

作用

1. 是担心程序员的技术不行，在编译阶段就爆出一个错误，目的在于提醒不要出错!

2. 编译时异常是可遇不可求。遇到了就遇到了呗。

异常处理机制

默认异常处理机制

1. 默认会在出现异常的代码那里自动的创建一个异常对象:ArithmeticException。

2. 异常会从方法中出现的点这里抛出给调用者，调用者最终抛出给JVM虚拟机

3. 虚拟机接收到异常对象后，先在控制台直接输出异常栈信息数据

4. 直接从当前执行的异常点干掉当前程序

5. 后续代码没有机会执行了，因为程序已经死亡。

 public static void main(String[] args) {
         System.out.println("程序开始===========");
         divide(10,0);
         System.out.println("程序结束===========");
     }
     public static void divide(int a , int b){
         System.out.println(a);
         System.out.println(b);
         int c = a / b;
         System.out.println(c);
     }

默认的异常处理机制并不好，一旦真的出现异常，程序立即死亡!

编译时异常处理机制

1. 出现异常直接抛出去给调用者，调用者也继续抛出去 （throws）

2. 出现异常自己捕获处理，不麻烦别人 （try-catch)

3. 前两者结合，出现异常直接抛出去给调用者，调用者捕获处理 （两者结合）

throws

用在方法上，可以将方法内部出现的异常抛出去给本方法的调用者处理.

这种方式并不好，发生异常的方法自己不处理异常，如果异常最终抛出去给虚拟机将引起程席死亡

格式：

 方法 throws 异常1,异常2,异常3...{
 }

规范做法：

 方法 throws Exception{
 }

 public static void main(String[] args) throws Exception {
     System.out.println("程序开始========");
     parseTime("2023-07-30 14:42:15");
     System.out.println("程序结束========");
 }
 ​
     private static void parseTime(String date) throws Exception {
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
         Date d = sdf.parse(date);
         System.out.println(d);
 ​
         InputStream i = new FileInputStream("C:/auif.jdg");
     }

try-catch

1. 监视捕获异常，用在方法内部，可以将方法内部出现的异常直接捕获处理

2. 这种方式还可以，发生异常的方法自己独立完成异常的处理，程序可以继续往下执行。

格式：

 try{
     // 监视可能出现异常的代码!
 }catch(异常类型1 变量){
     //处理异常
 }catch(异常类型2 变量){
     //处理异常
 }...

建议格式：

 try{
     //可能出现异常的代码!
 }catch(Exception e){
     e.printStackTrace(); //直接打印异常栈信息
 }...
 Exception 可以捕获处理一切异常类型！

代码：

 try {
             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
             Date d = sdf.parse(date);
             System.out.println(d);
 ​
             InputStream i = new FileInputStream("C:/auif.jdg");
         }
         catch (Exception e) {
             e.printStackTrace();//打印异常栈信息

throws 和try-catch结合

 public static void main(String[] args) {
         System.out.println("程序开始========");
         try {
             parseTime("2023-07-30 14:42:15");
             System.out.println("功能操作成功");
         } catch (Exception e) {
             e.printStackTrace();
             System.out.println("功能操作失败");
         }
         System.out.println("程序结束========");
     }
     private static void parseTime(String date) throws Exception {
             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
             Date d = sdf.parse(date);
             System.out.println(d);
 ​
             InputStream i = new FileInputStream("C:/auif.jdg");
     }

自定义异常

1、自定义编译时异常

1. 定义一个异常类继承Exception.

2. 重写构造器。

3. 在出现异常的地方用throw new 自定义对象抛出

4. 作用:编译时异常是编译阶段就报错，醒更加强烈，一定需要处理！！

代码实现

1. 自定义的异常类

 public class IthengAgeIlleagalException extends Exception{
 ​
     public IthengAgeIlleagalException() {
     }
 ​
     public IthengAgeIlleagalException(String message) {
         super(message);
     }
 }

2. Test类

 public class ExceptionDemo {
     public static void main(String[] args) {
         try {
             checkAge(-34);
         } catch (IthengAgeIlleagalException e) {
             e.printStackTrace();
         }
     }
     public static void checkAge(int age) throws IthengAgeIlleagalException {
         if (age < 0 || age >200){
             //抛出去一个异常
             //throw:  在方法内部直接创建一个异常对象，并从此点抛出
             //throws: 用在方法申明上的，抛出方法内部的异常
             throw new IthengAgeIlleagalException(age + " is illegal");
         }else{
             System.out.println("年龄合法，给其推荐商品");
         }
     }
 }

2、自定义运行时异常

1. 定义一个异常类继承RuntimeException

2. 重写构造器

3. 在出现异常的地方用throw new 自定义对象抛出！

4. 作用:提醒不强烈，编译阶段不报错！！运行时才可能出现！！

代码实现

1. 自定义的运行时异常类

 public class IthengAgeRuntimeException extends Exception{
 ​
     public IthengAgeRuntimeException() {
     }
 ​
     public IthengAgeRuntimeException(String message) {
         super(message);
     }
 }

2. Test类

 public static void main(String[] args) {
         try {
             checkAge(-34);
         } catch (IthengAgeRuntimeException e) {
             e.printStackTrace();
             System.out.println("出错了");
         }
     }
     
         public static void checkAge(int age) throws IthengAgeRuntimeException{
             if (age < 0 || age > 200) {
                 throw new IthengAgeRuntimeException(age + " is illegal");
             } else {
                 System.out.println("年龄合法，给其推荐商品");
             }
         }