二十九、异常处理

目录

①前言:

②常见的运行时异常

③常见的编译时异常

④异常的处理机制

⑤自定义异常

---

①前言:

1.什么是异常？

        异常是程序在“编译”或者“执行”的过程中可能出现的问题，注意：语法错误不算在异常体系中。

        比如:   数据索引越界异常，空指针异常，日期格式异常，等。

2.为什么要学习异常？

        异常一旦出现，如果没有提前处理，程序就会退出JVM虚拟机而终止。

        研究异常并且避免异常，然后提前处理异常，体现的是程序的安全，健壮性。

3.异常体系

        Error: 系统级别的问题，JVM退出等，代码无法控制。

        Exception： java.lang包下，称为异常类，它表示程序本身可以处理的问题。

        RuntimeException及其子类: 运行时异常，编译阶段不会报错。(空指针异常，数组索引越界异常)

        除RuntimeException之外的所有异常: 编译时异常，编译器必须处理的，否则程序不能通过编译。(日期格式化异常)

4.编译时异常和运行时异常

        javac.exe 编译时异常，是在编译成class文件时必须要处理的异常，也称之为受检异常。

        java.exe 运行时异常，在编译成class文件不需要处理，在运行字节码文件时可能出现的异常。

简单来说:

        编译时异常，就是在编译时就出现的异常；

        运行时异常，就是在运行时出现的异常。

②常见的运行时异常

1.运行时异常

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

2.运行时异常示例:

        ①数据索引越界异常ArrayIndexOutOfBoundsException

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

        ③类型转换异常ClassCastException

        ④数学操作异常ArithmeticException

        ⑤数字转换异常NumberFormatException

运行时异常:

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

3.代码演示:

import java.io.FileInputStream;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
​
/**异常  程序在编译或运行中出现错误（语法错误不算在异常体系中）
 * Throwable
 * Error  系统级别的错误
 * Exception  程序级别的异常（RuntimeException  运行时异常 ） 编译时异常（受检异常）
 */
public class Exception_Demo1 {
    public static void main(String[] args) throws ParseException {
        //运行时异常
//        //1.数据索引越界异常ArrayIndexOutOfBoundsException
//        int[] arr = {10,21,34};
//        System.out.println(arr[3]);//越界异常
//        //2.空指针异常NullPointerException  直接输出没问题，但调用空指针的变量的功能就会报错
//        String name = null;
//        System.out.println(name);
//        System.out.println(name.length());
//        //3.类型转换异常ClassCastException
//        Object o = 23;
//        String s = (String) o;
//        //4.数学操作异常ArithmeticException
//        int c = 10/0;
//        //5.数据转换异常NumberFormatException
//        String number = "23 aa  bb";
//        Integer it = Integer.valueOf(number);
//        System.out.println(it+1);
    }
}

③常见的编译时异常

1.编译时异常

        除RuntimeException之外的所有异常，编译阶段就报错，必须处理，否则代码不通过。

2.编译时异常的作用是什么？

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

3.代码演示:

import java.io.FileInputStream;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
​
/**
 * 编译时异常的解决方式：
 * 1、抛出异常：只能抛出一个异常
 * 抛出异常规范操作 直接抛出throws Exception{}
 * 抛出异常并不好，如果异常最终抛出去给虚拟机会引起程序死亡
 *2、 监视捕获异常格式 ：捕获异常
 * try{
 * 监视可能出现异常的代码
 * }catch(异常类型1 变量){
 * //处理异常
 * }
 * 3、 前两者结合
 *
 * 运行时异常处理方式:
 * 编译阶段不会报错，可以不抛，默认抛上去
 */
public class Exception_Demo1 {
    public static void main(String[] args) throws ParseException {
        //编译时异常
        //简单日期格式化类
//        String date = "2015-01-12  10:23:21";
//        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//        //解析字符串成为日期对象
//        Date d = sdf.parse(date);
//        System.out.println(d);
        passTime("2022-12-11 12:24:13");
    }
    public static void passTime(String date){
​
        System.out.println("--------------------------------------");
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Date d = sdf.parse(date);
            System.out.println(d);
        } catch (Exception e) {
//            e.printStackTrace();//打印异常栈信息
            System.out.println("出现了解析时间异常");
        }
        try {
            InputStream is = new FileInputStream("E:/meinv.jpg");
        } catch (Exception ex) {
//            ex.printStackTrace();
            System.out.println("没有这个文件，不要骗我");
        }
    }
}

④异常的处理机制

1.编译时异常

        编译时异常是编译阶段就出错的，所以必须处理，否则代码根本无法通过。

2.编译时异常的处理形式有三种:

        ①出现异常直接抛出去给调用者，调用者也继续抛出去。

        ②出现异常自己捕获处理，不麻烦别人；

        ③前两者结合，出现异常直接抛出去给调用者，调用者捕获处理。

3.异常处理方式之一:throws

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

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

抛出异常格式:

规范做法:

 

4.异常处理方式之二：try...catch...

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

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

格式：

 

5.异常处理方式之三:前两者结合

        方法直接将异常通过throws抛出去给调用者

        调用者收到异常后直接捕获处理。

6.代码演示:

import java.io.FileInputStream;
import java.io.InputStream;
import java.text.SimpleDateFormat;
import java.util.Date;
​
/**
    Exception 异常处理方式
 */
public class Exception_Test1 {
    //异常处理方式之二：try...catch...
    public static void main(String[] args) {
        System.out.println("程序开始~~");
        try {
            passTime("2022-12-11 12:24:13");
            System.out.println("程序操作成功~~");
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("程序操作失败~~");
        }
        System.out.println("程序结束~~");
    }
​
    //异常处理方式之一:throws
    public static void passTime(String date) throws Exception{
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d = sdf.parse(date);
        System.out.println(d);
​
        InputStream is = new FileInputStream("E:/meinv.jpg");
    }
}

7.异常处理的总结

        在开发中按照规范来说第三种方式是最好的:底层的异常抛出去给最外层，最外层集中捕获处理。

        实际应用中，只要代码能够编译通过，并且功能能完成，那么每一种异常处理方式似乎也都是可以的。

8.案例:异常处理使代码更稳健的案例

需求:

        键盘录入一个合理的价格为止(必须是数值，值必须大于0)。

分析:

        定义一个死循环，让用户不断的输入价格；

import java.util.Scanner;
​
/**  案例
 *  键盘录入一个合理的价格位置
 *  定义一个死循环，不断输入价格
 */
public class Exception_Test2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (true) {
            try {
                System.out.println("请您输入一个合理的价格");
                String priceStr = sc.nextLine();//接一行数据
                //转换成double类型的价格  判断价格大于0
                double price = Double.valueOf(priceStr);
                if (price >0) {
                    System.out.println("定价:"+price);
                    break;
                }else {
                    System.out.println("价格必须是正数~~");
                }
            } catch (NumberFormatException e) {
                System.out.println("用户输入的数据无效，请您输入合法的数据");
            }
        }
        System.out.println("----------------------------------");
​
        //自定义异常
        try {
            checkAge(34);
        } catch (Exception_Demo2 e) {
            throw new RuntimeException(e);
        }
    }
    public static void checkAge(int age) throws Exception_Demo2 {
        if (age<0 || age>200){
            //抛出去一个异常对象给调用者
            //throw:在方法内部直接创建一个异常对象，并由此点抛出
            //throws:用在方法上面声明上的，抛出方法内部的异常
            throw new Exception_Demo2(age+"IS Illeagal!");
        }else {
            System.out.println("年龄合法，推荐商品给其购买");
        }
    }
}

⑤自定义异常

1.自定义异常的必要？

        java无法为这个世界上全部问题提供异常类。

        如果企业想通过异常的方式来管理自己的某个业务问题，就需要自定义异常类了。

2.自定义异常的好处？

        可以使用异常的机制管理业务问题，如提醒程序员注意；

        同时一旦出现bug，可以用异常的形式清晰的指出出错的地方。

3.自定义异常的分类

        (1)自定义编译时异常

                ①定义一个异常继承Exception；

                ②重写构造器；

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

        作用:

                编译时异常是编译阶段就报错，提醒更加强烈，一定需要处理。

代码演示:

/**自定义异常
 * 1、自定义编译异常
 * 1。继承Exception
 * 2.重写构造器
 * 3.在出现异常的地方，用throw new自定义对象抛出
 * 作用:编译时异常编译时就报错，提醒更加强烈，一定需要处理
 *
 * 2、自定义运行异常
 * 1。继承RuntimeException
 * 2.重写构造器
 * 3.在出现异常的地方，用throw new自定义对象抛出
 * 作用:运行时才出现
 *
 *
 * throw:在方法内部直接创建一个异常对象，并由此点抛出
 * throws:用在方法上面声明上的，抛出方法内部的异常
 */
public class Exception_Demo2 extends Exception {
    public static void main(String[] args) {
        try {
            checkAge(-34);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
​
    public static void checkAge(int age)throws Exception{
        if (age < 0 || age > 200){
            /*抛出一个异常对象给调用者
            throw:在方法内部直接创建一个异常对象，并从此点抛出。
            throws:用在方法申明上的，抛出方法内部的异常。
             */
​
            throw new Exception(age+"is illeagal");
        }else {
            System.out.println("年龄合法:推荐商品给其购买~~~");
        }
    }
}

        (2)自定义运行时异常

                ①定义一个异常类继承RuntimeException;

                ②重写构造器；

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

        作用:

                提醒不强烈，编译阶段不报错，运行时才可能出现。