Java基础篇异常处理总结

1.异常概述

1.1概念

   在Java语言中，将程序执行中发生的不正常情况称为“异常”。 (开发过程中的语法错误和逻辑错误不是异常)

1.2异常的体系结构

异常主要分为编译时异常和运行时异常

java.lang.Throwable
   |-----java.lang.Error:一般不编写针对性的代码进行处理。
   |-----java.lang.Exception:可以进行异常的处理
       |------编译时异常(checked)
            |-----IOException
               |-----FileNotFoundException
            |-----ClassNotFoundException
       |------运行时异常(unchecked,RuntimeException)
            |-----NullPointerException
            |-----ArrayIndexOutOfBoundsException
            |-----ClassCastException
            |-----NumberFormatException
            |-----InputMismatchException
            |-----ArithmeticException

1.3异常的分类

     运行时异常：是指编译器不要求强制处置的异常。一般是指编程时的逻辑错误，是程序员应该积极避免其出现的异常,对于此类异常一般不做处理
     编译时异常：是指编译器要求必须处置的异常。即程序在运行时由于外界因素造成的一般性异常。

2.异常的处理

2.1异常处理的“抓抛模型”

过程一：“抛”：程序正在执行的过程中，一旦抛出异常，就会在异常代码处生成一个对应的异常类对象 并将此对象抛出。
     一旦抛出对象以后，其后的代码就不再执行。

关于异常对象的产生：
①系统自动生成一个异常对象
②手动的生成一个异常对象，并抛出throw

过程二：“抓”：可以理解为异常的处理方式：①try-catch-finally ② throws

2.2异常处理的方式一：try-catch-finally

使用的方式：

说明（理解很重要）：

 1.finally是可选的
 2.使用try将可能出现的异常代码包装起来，在执行过程中，一旦出现异常，就会生成一个异常类的对象，根据此对象的类型，去catch中进行匹配
 3.一旦try中的异常对象对象匹配到某一个catch时，就会进入catch中进行异常处理，一旦处理完成，就跳出try-catch结构，继续执行其后的代码
 4.catch中的异常类型如果没有子父类关系，则谁声明在上，谁声明在下无所谓catch中的异常类型如果有子父类关系，则子类要声明在父类上面
 5.常见的异常处理方式：
    ①getMessage() ②e.printStackTrace();
 6.使用try-catch处理编译异常时，使得程序在编译时不报错，运行时还可能会报错, 相当于将一个编译时出现的错误，延时到运行时出现
 7.try-catch-finally结构可以再次嵌套try-catch
  在开发中，针对运行时异常一般不做处理，对于编译时异常使用try-catch-finally进行处理

使用样例：

public class ExceptionTest1 {

    public static void main(String[] args) {

    }

	//ArithmeticException 算术运算异常
    @Test
    public void Test6() {
        try {
            int a = 10;
            int b = 0;
            System.out.println(a / b);
        }catch (ArithmeticException e){
            e.printStackTrace();
        }

    }


   @Test
   public void Test2(){
        try{
            File file = new File("hello.txt");
            FileInputStream fis = new FileInputStream(file);

            int data = fis.read();
            while(data != -1){
                System.out.print((char) data);
                data = fis.read();
            }
            fis.close();
        }catch (FileNotFoundException e){
            e.printStackTrace();
        }catch (IOException e){
            e.printStackTrace();
        }

   }

    //NumberFormatException数据格式异常
    @Test
    public void Test4() {
        String str = "123";
        str = "abc";
        try {
            int number = Integer.parseInt(str);//把字符串转为整型
        }catch (NumberFormatException e){
           // System.out.println("出现数值转换异常了");
            e.printStackTrace();
            System.out.println(e.getMessage());//获取异常信息
        }catch (NullPointerException e){
            System.out.println("出现空指针异常了");
        }catch (Exception e){
            System.out.println("出现异常了");
        }

    }
}

🍀finally的使用
说明：

1.finally是可以选择写，也可以选择不写的，具体情况具体分析，如果有必须要执行的就需要写
2.finally中声明的是一定会被执行的代码，即使catch中又出现异常了，try中有return语句，catch中有return语句等情况。
3.像数据库连接、数据输入输出流、网络编程Socket等资源，JVM是不能进行自动回收的，我们需要自己手动的进行资源的释放。此时的资源释放，就需要声明在finally中。

使用样例一：

public int test2() {
        try {
            int[] arr = new int[10];
            System.out.println(arr[10]);
            return 1;
        } catch (ArrayIndexOutOfBoundsException e) {
            e.printStackTrace();
            return 2;
        } finally {
            System.out.println("一定会被执行");
        }
    }

使用样例二：

@Test
    public void test3() {
        FileInputStream fis = null;//需要初始化
        try {
            File file = new File("C:\\Users\\Administrator\\Desktop\\com.java.li\\src\\day10\\com\\it\\java0\\hello.txt");
            fis = new FileInputStream(file);
            //可能此处出现异常，所以他会直接到第一个异常处理机制里面，因此fis.close()可能不会被关闭
            //--》fis.close()放在while下面显然有些不合适,他是一定会执行的语句，所以放在finally里比较好
            //异常套异常

            int data = fis.read();
            while (data != -1) {
                System.out.print((char) data);
                data = fis.read();
            }
            //fis.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fis != null){
                    fis.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

2.3异常处理的方式二：throws + 异常类型

1.概述：

“throws + 异常类型”写在方法的声明处，指明此方法在执行时可能会出现的异常类型。
    当方法体执行出现异常时，仍会在异常代码处生成一个一场类的对象，此时对象满足throws后的异常类型时，就会被抛出，异常代码的后续代码就不会被执行！

2.两种方式之间的区别：

“try-catch-finally”真正的将异常处理掉了
“throws + 异常类型”只是将异常抛出给方法的调用者，并没有将异常真正处理掉

注意：子类的异常类型不大于父类的异常类型

throws使用样例：

public class ExceptionTest2 {
    public static void main(String[] args) {

        try {
            method2();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void method2()throws IOException{
        method1();
    }

    public static void method1()throws  IOException {
        File file = new File("C:\\Users\\Administrator\\Desktop\\com.java.li\\src\\day10\\com\\it\\java0\\hello.txt");
        FileInputStream fis = new FileInputStream(file);

        int data = fis.read();
        while(data != -1){
            System.out.print((char) data);
            data = fis.read();
        }
        fis.close();
    }
}

2.4如何选择异常处理方式

方式一：

     如果父类中被重写的方法没有throws的方式处理异常，则子类被重写的方法也不能使用throws的方式，意味着子类重写方法的异常必须使用try-catch-finally的方式处理异常

方式二：

    执行的方法a中，先后又调用了另外几个方法，这几个方法是递进的关系，(方法一的结果传递给方法二，方法二的结果传递给方法三)，建议这几个方法使用throws的方式进行处理。而执行的方法a可以考虑使用try-catch-finally的方式处理异常

3.手动处理异常

1.概述：

    在程序执行的过程中，除了自动抛出异常对象的情况之外，我们还可以手动的throw一个异常对象。

3.1throw和throws之间的区别

throw:表示抛出一个异常类的对象，生成异常类的对象的过程；声明在方法体内

throws属于异常处理方式的一种，声明在方法体外。

3.2throw典型例题

测试类：

public class StudentTest {

    public static void main(String[] args) {

        try {
            Student student = new Student();
            student.regist(-100);
            System.out.println(student);
        } catch (Exception e) {
            e.printStackTrace();
            e.getMessage();
        }

    }
}

Student类：

class Student {

    private int id;

    public void regist(int id)  throws Exception{//处理方法二抛出一个异常
        if (id > 0) {
            this.id = id;
        } else {//手动抛出一个异常处理方法1
            //throw new RuntimeException("输入的数据有误");

            //方式二
            //throw new Exception("输入的数据有误");

            //方式三，使用自定义异常
            throw new MyException("输入的数据为负数");
        }
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                '}';
    }
}

手写异常类：

public class MyException extends RuntimeException{

    static final long serialVersionUID = 7034897101145766939L;

    public MyException(){
    }

    public MyException(String msg){
        super(msg);
    }
}

3.3自定义异常类的实现

实现自定义异常类的步骤：

1.继承于现有的异常结构，RuntimeException,Exception
2.提供全局常量：serialVersionUID
3.提供重载的构造器

样例：

public class MyException extends RuntimeException{

    static final long serialVersionUID = 7034897101145766939L;

    public MyException(){
    }

    public MyException(String msg){
        super(msg);
    }
}