Exception笔记

破车博特

已于 2022-11-02 15:07:20 修改

阅读量216

点赞数

分类专栏： Java 文章标签： java 学习 jvm

于 2022-10-30 15:17:04 首次发布

本文链接：https://blog.csdn.net/MsXintu/article/details/127599636

版权

Java 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

前言:

本文章是针对我的学习所做的一些笔记，以及对知识点的测试

知识点分部讲解：

1.基本概述

1.异常以类对象的方法存在，当程序某段代码发生异常，会产生异常对象
2、异常的分类
两类型又有相应的子类
2.1:Exception 的子类为： RuntimeException（运行异常）可处理，也可不处理，
IOException（受检异常）：必须处理，不然报错，该两类下又有相应具体的子类 2.2:Error 子类参考文档

2.处理异常的方法

// 当出现异常有两种处理方法：
//1 .通过throws 往上抛异常，直到被解决为止
//2 .通过 try catch语句直接捕获异常，进行处理，
//2.1 当try语句块中有多个异常可以，增加多个catch块，分别解决各个异常
// 相关例子在： TestException 类中

// 测试处理异常出现的两种方法：
// 1.throws :()
// 2.try {} catch (异常类 变量){}：
/* try{ 语句1；
        抛出异常语句
        语句2     }   语句2不执行，直接转跳执行 catch 语句块*/
// 2.1 catch语句可以捕捉该异常的父类（这是多态原理，父类引用指向子类对象）

// 什么时候决定throws ，什么时候决定 try catch，根据具体情况而定，
// 例如想让上一级调用者知道就throws向上抛出，不想则就地解决，try catch

import java.io.IOException;

public class TestException {
    public static void main(String[] args) {
        System.out.println("main beg!");
        m1();

        System.out.println("main end!");
    }

    public static void m1() {
        System.out.println("m1 beg!");
        m2();
        System.out.println("m1 end!");
    }

    private static void m2() {
        System.out.println("m2 beg!");
        m3();
        System.out.println("m2 beg!");
    }

    private static void m3() {
        System.out.println("m3 beg!");
        // 直接在抛出异常除直接捕获异常，并对其处理
        try {
            throw new ClassNotFoundException("sadasdsads");// 抛出一个受检异常
        } catch (ReflectiveOperationException e) {  // catch 对象也可以写为该对象的  父类ReflectiveOperationException
            // 为ClassNotFoundException的父类
            System.out.println("处理了奥");
        }
    }
}

3.finally关键字

finally{}语句块
finally{}语句块一定与try{} catch 并用，放在catch（）{}之和
相关例子在： TestException02 类中

//-------------知识点
//1.当打开输入流时候，即new 出输入流类对象后，在使用完后需要将其 关闭，即调用  输入流对象.close（）方法将其关闭，不然会耗内存
//2. 用try{} catch（异常类 a）{} 处理异常时候，要习惯性在 catch语句块加上 a.printStackTrace() 输出异常错误信息（方便寻找）
//3. 当出现异常时 ：查找错误信息，前面 SUN公司写的代码就不用看了，直接看到我们写的代码 ，从第一句看起******
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class TestException02 {
    public static void main(String[] args) {
        System.out.println("main beg!");
        m1();

        System.out.println("main end!");
    }

    public static void m1() {
        System.out.println("m1 beg!");
        m2();
        System.out.println("m1 end!");
    }

    private static void m2() {
        System.out.println("m2 beg!");
        m3();
        System.out.println("m2 beg!");
    }

    private static void m3() {
        FileInputStream s=null;// 定义一个输入流类变量
        try {
            s=new FileInputStream("D:\\公选课笔记\\劳动法\\标志劳动法产生的法律.png");// new 输入流对象，调用父类构造方法，
                                                                                    // throws一个FileNotFoundException异常
            System.out.println("m3未发生异常！");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }finally {   // finally 关键字
            if (s!=null){
                try {
                    s.close();
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
            }

        }

    }
}

// 五、try {} 和 finally 可以并用，不加catch语句也行，当try{}中有return 语句时候的执行情况
// 执行顺序为：return 语句之前的语句先执行，再执行 finally {}内的语句，最后执行 return
// 相关例子在： TestException03 类中

// 以下例子为啥输出100，而不是101的原因是：
// 1.程序的代码由上往下执行（亘古不变）
// 2.最后才执行return （这是SUN公司）规定的：try 和finally连用加上return语句
// 3.为了同时满足以上两个原因，SUN公司定义一个临时变量j，将i=100赋给j，返回的值为 j的值
public class TestException03 {
    public static void main(String[] args) {
        System.out.println(m1());

    }

    public static int  m1(){
        int i=100;
        try {
            System.out.println("m1()方法beg！" );
            return i;
        }finally {
            i++;
            System.out.println("finally块中执行");
        }

    }
}

4.自定义异常类

// 步骤：一.创建一个类，去继承Exception / RuntimeException
// 二.在类中创建两个方法： 1.无参构造 2.带String参数的有参构造，调用父类的有参构造方法
//
// 相关例子在： TestException04 类中


public class TestException04 {
    public static void main(String[] args) {
        System.out.println("beg！");
        try {
            test();
        } catch (MyException e) {
            e.printStackTrace();
        }

    }

    public static void test() throws MyException {
        throw new MyException(); // 抛出自定义异常
    }
}


//创建自己的异常类
class MyException extends Exception{
    public MyException(){

    }
    public MyException(String s){

        super(s);
    }
}

5. 处理异常需要注意的知识：

//1.当打开输入流时候，即new 出输入流类对象后，在使用完后需要将其关闭，即调用输入流对象.close（）方法将其关闭，不然会耗内存
//2. 用try{} catch（异常类 a）{} 处理异常时候，要习惯性在 catch语句块加上 a.printStackTrace() 输出异常错误信息（方便寻找）
//3. 当出现异常时：查找错误信息，前面 SUN公司写的代码就不用看了，直接看到我们写的代码，从第一句看起******