异常处理机制-CSDN博客

本文链接：https://blog.csdn.net/m0_57068311/article/details/128540499

1.异常概述

异常的体系

异常的体系分为Error和Eception两个子类 Error系统级别的问题，代码无法控制

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

2.异常分类

1.运行时异常 RunTimeException

在编译时不会报错，但是运行的时候会出问题并且JVM会直接结束程序。

代码：

package com.itheima.Exception;

public class ExceptionDemo {
    public static void main(String[] args) {
        //RuntimeException  运行时异常
        // 1.数组越界异常
        int[] arr = {1,2};
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println("检测");
        //2.空指针异常 NullPointerException 直接输出没有问题，但是调用空指针的变量的功能就会报错
        String name = null;
        System.out.println(name);
        System.out.println(name.length()); //运行出错
        //3.类型转换异常 ClassCastExcpeiton
        Object o = 23;
        String s= (String)o;
        //4.数学操作异常
        System.out.println(10/0);
        //5.数字转换异常
        String sc = "23aabb";
        Integer a=  Integer.valueOf(sc);
        System.out.println(a);
    }
}

2.编译时异常

不是RunTimeExcpetion的子类的异常，在编译阶段就报错，提醒你这个地方可能会出问题。

代码：

package com.itheima.exception_javac;

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

public class Demo {
    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); //提示你格式可能出错
    }
}

异常的默认处理机制：

3.异常处理

1.编译时异常处理

处理方式1：throws 直接抛出异常

throws：用在方法上这种处理异常的方式并不好，因为当最底层方法一层一层抛给虚拟机的时候，最终交给虚拟机，JVM在接到处理的异常的时候会直接终结掉程序，这样出异常后面的代码就不会在执行了。虽然一个方法可以抛出很多异常，但是异常

代码：

package com.itheima.ExceptionDemo;

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


//这种在方法上直接抛的机制  跟默认机制没有区别 都是不处理直接抛给虚拟机
public class ExceptionDemo1 {
    public static void main(String[] args) throws ParseException {
        System.out.println("程序开始");
        parseTime("2011-11-11 11:11:11");
    }

    private static void parseTime(String s) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d= sdf.parse(s);
    }
}

处理方式2： try catch

比较好的方法，可以将方法体全部用try，catch包裹，这样在捕获到异常的时候可以直接在catch中打印出来。

坏处：他会在底层代码自己处理掉异常，但是不会将异常抛给方法栈。因此如果程序出现异常，用这种方法你是不能知道他哪里出了问题的。

代码：

package com.itheima.ExceptionDemo;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class ExceptionDemo2 {
    public static void main(String[] args)  {
        System.out.println("程序开始");
        parseTime("2011-11-11 11:11:11");
    }

    private static void parseTime(String s)   {

        Date d= null;
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            d = sdf.parse(s);
            System.out.println(d);

            InputStream is = new FileInputStream("E:/meinv.jpg");
        } catch (Exception e) {
            e.printStackTrace();
        }


    }
}

处理方式3：两种方式结合

在底层代码抛出异常给上层调用者，在上层调用者中处理异常

好处：当你程序出现异常的时候，哪里出现问题会发现的很快。

代码：

package com.itheima.ExceptionDemo;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class ExceptionDemo3 {

    public static void main(String[] args) throws ParseException {
        System.out.println("程序开始");
        try {
            parseTime("2011-11-11 11:11:11");
            System.out.println("程序执行成功");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("功能操作失败");
        }
        System.out.println("程序结束");
    }

    private static void parseTime(String s) throws ParseException, FileNotFoundException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d= sdf.parse(s);
        System.out.println(d);

        InputStream is =new FileInputStream("D:");
    }
}

2.运行时处理异常

package com.itheima.Exception;

public class Test {
    public static void main(String[] args) {
        System.out.println("程序开始。。。。");
        try {
            chu(10,0);  
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("程序结束。。。。。");
    }

    private static void chu(int i, int i1) throws Exception {
        System.out.println(i);
        System.out.println(i1);
        int c = i / i1;
        System.out.println(c);
    }
}

总结：

自定义异常

唯一的区别就是：运行时异常在编译的时候不会报错

//自定义异常在类中继承Exception类

package com.itheima.Exception_custom;

/*
自定义异常
继承Exception
重写构造器
 */
public class ItheimaException extends Exception{
    public ItheimaException()
    {

    }
    public ItheimaException(String message)
    {
        super(message);
    }
}

package com.itheima.Exception_custom;

public class Demo {
    public static void main(String[] args) {
        try {
            checkAge(201);
        } catch (ItheimaException e) {
            e.printStackTrace();
        }
    }

    public static void checkAge(int age) throws ItheimaException {
        if (age <0 || age>200)
        {
            //跑出去一个异常给调用者
            //throw 在方法内部直接创建一个异常对象 并从此点抛出
            //throws 用在方法申明上额 抛出方法内部的异常
            throw new ItheimaException(age + " is illeagal");
        }else {
            System.out.println("年龄合法");
        }
    }
}