异常机制-异常分类

异常机制的本质：当程序出现异常，程序安全的退出、处理完后继续执行的机制

异常的概念：

异常指程序运行过程中出现的非正常现象，例如除数为零、需要处理的文件不存在、数组下标越界等。在Java的异常处理机制中，引进了很多用来描述和处理异常的类，称为异常类。异常类定义中包含了该类异常的信息和对异常进行处理的方法。我们开始看我们的第一个异常对象，并分析一下异常机制是如何工作的。 例如：以下报错

public class Test {
    public static void main(String[] args) {
        System.out.println("111");
        int a = 1/0;
        System.out.println(222);
    }
}

如果我们加上了try catch:

public class Test {
    public static void main(String[] args) {
        System.out.println("111");
        try {
            int a = 1/0;
        } catch(Exception e) {
            e.printStackTrace();  // 打印错误信息
        }

        System.out.println(222);
    }
}

Java是采用面向对象的方式处理异常的

处理过程：

1. 抛出异常：当执行一个方法时，如果发生异常，则这个方法生成该异常的一个对象，停止当前执行路径，并把异常对象提交给JRE。

2. 捕获异常：JRE得到该异常后，寻找相应代码处理该异常，JRE在方法的调用栈中寻找，从生成异常的方法开始回溯，直到找到相应的代码异常为止。

异常的分类: Error、Exception

Java对异常进行了分类，不同类型的异常分别用不同的java类进行表示，所有异常的根类为java.lang.Throwable. 其下面又派生了两个子类：Error 和 Exception.

Error

Error是程序无法处理的错误，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时JVM（Java虚拟机）出现的问题。

例如，Java虚拟机运行错误（VirtualMachineError），当JVM不再有继续执行操作所需的内存资源时，将出现OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。Error表明系统JVM已经处于不可恢复的崩溃状态中。

Exception分类：RuntimeException、CheckedException

Exception是程序能够处理的异常，通常分类两类：

1. RuntimeException 运行时异常
2. CheckedException 编译异常

RuntimeException运行时异常：

如被0除、数组下标越界、空指针等，编译器不处理RuntimeException,程序员需要增加"逻辑处理来避免这些异常"。

1. 例如：ArithmeticException异常：试图除以0

public class Test {
    public static void main(String[] args) {
        int b = 0;
        System.out.println(1/b);
    }
}

则可以增加逻辑处理：

public class Test {
    public static void main(String[] args) {
        int b = 0;
        if (b != 0) {
            System.out.println(1/b);
        }
    }
}

2. 再例如：NullPointerException空指针异常

解决空指针异常，通常是加上非空判断；

public class Test {
    public static void main(String[] args) {
        String str = null;
        if (str != null) {
            System.out.println(str.charAt(0));
        }
    }
}

3. 例如：ClassCastException异常

class Animal {

}

class Dog extends Animal {

}

class Cat extends Animal {

}

public class Test {
    public static void main(String[] args) {
        Animal c = new Cat();
        Dog d = (Dog)c;
    }
}

则解决方式：

public class Test {
    public static void main(String[] args) {
        Animal c = new Cat();
        if (c instanceof Dog) {
            Dog d = (Dog)c;
        }
    }
}

4. ArrayIndexOutOfBoundsException异常

则需要加上边界逻辑判断

public class Test {
    public static void main(String[] args) {
        int[] list = new int[5];
        int a = 5;
        if (a < list.length) {
            System.out.println(list[5]);
        }
    }
}

5. NumberFormatException异常

public class Test {
    public static void main(String[] args) {
        String a = "12345abc";
        System.out.println(Integer.parseInt(a));
    }
}

数字格式化异常的解决，可以引入正则表达式判断是否为数字：

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Test {
    public static void main(String[] args) {
        String a = "12345abc";
        Pattern p = Pattern.compile("^\d+$");
        Matcher m = p.matcher(a);
        if (m.matches()) {
            System.out.println(Integer.parseInt(a));
        }
    }
}

CheckedException编译异常：

CheckedException异常在编译时就必须处理，否则无法通过编译。

1. 异常处理方式之一 捕获异常(try-catch-finally)

• try

  语句指定了一段代码，该段代码就是异常捕获并处理的范围。在执行过程中，当任意一条语句产生异常时，就会跳过该条语句中后面的代码。代码中可能会产生并抛出一种或几种类型的异常对象，它后面的catch语句要分别对这些异常做相应的处理。一个try语句必须带有至少一个catch语句块或一个finally语句块。

  注意：当异常处理的代码执行结束以后，不会回到try语句去执行尚未执行的代码。

• catch

  每个try语句块可以伴随一个或多个catch语句，用于处理可能产生的不同类型的异常对象。

  catch捕获异常时的捕获顺序：如果异常类之间有继承关系，先捕获子类异常再捕获父类异常。

• finally

  不管是否发生了异常，都必须要执行。

  通常在finally中关闭已打开的资源，比如：关闭文件流、释放数据库连接等。

try-catch-finally执行过程

语句块的执行过程详细分析：程序首先执行可能发生异常的try语句块。如果try语句没有出现异常则执行完后跳至finally语句块执行；如果try语句出现异常，则中断执行并根据发生的异常类型跳至相应的catch语句块执行处理。catch语句块可以有多个，分别捕获不同类型的异常。catch语句块执行完后程序会继续执行finally语句块。finally语句是可选的，如果有的话，则不管是否发生异常，finally语句都会被执行。

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Test {
    public static void main(String[] args) throws IOException {
        String username = System.getProperty("user.home");// macOS 上，每个用户的桌面路径通常为 /Users/用户名/Desktop
        System.out.println(username);
        File desktop = new File(username, "Desktop/demo.txt");
        FileReader reader = null;
        try {
            reader = new FileReader(desktop);
            char a = (char)reader.read();
            char b = (char)reader.read();
            System.out.println(a);
            System.out.println(b);
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            try {
                if (reader != null) {
                    reader.close();
                }
            } catch(Exception e) {
                e.printStackTrace();
            }

        }

    }
}

常用开发环境中，给代码块自动加try catch的快捷键

1. 选中代码
2. widonw系统：ctrl + alt + t;

MacOs系统：Command + Option + T;

异常处理方式之二 声明异常（throws子句）

1. CheckedException 产生时，并不一定立即处理它，可以把异常throws, 而是由调用者处理它。
2. 一个方法抛出多个已检查异常，就必须在方法的首部列出所有的异常

// 测试CheckedException (已检查异常，编译器报错)
public class Test {
    public static void main(String[] args) {
        String username = System.getProperty("user.home");// macOS 上，每个用户的桌面路径通常为 /Users/用户名/Desktop
        System.out.println(username);
        File file = new File(username, "Desktop/demo.txt");
        file.createNewFile(); // 报错
    }
}

所以可以加throws: 按照 options + enter键（alt + enter）

// 测试CheckedException (已检查异常，编译器报错)
public class Test {
    public static void main(String[] args) throws IOException {
        String username = System.getProperty("user.home");// macOS 上，每个用户的桌面路径通常为 /Users/用户名/Desktop
        System.out.println(username);
        File file = new File(username, "Desktop/demo.txt");
        file.createNewFile();
    }
}

在例如：

try-catch-resource自动关闭AutoCloseable接口资源

java中，jvm的垃圾回收机制可以对内部资源实现自动回收，给开发者带来了极大便利。但JVM对外部资源（调用了底层操作系统的资源）的引用却无法自动回收，例如数据库连接，网络连接或者输入输出IO流等，这些连接就需要我们手动去关闭，不然会导致外部资源泄漏，连接池溢出以及文件被异常占用等情况。

JDK7之后，出现了try-with-resource.它可以自动关闭实现了AutoCloseable接口的类。try-with-resource声明将 try-catch-finally 简化为 try-catch,这其实已一种语法糖，在编译时仍然是try-catch-finally。