异常的处理

1. try —— catch —— finally

用法

	try {
        // 可能出现异常的代码
    } catch (可能出现的异常类型 变量名) {

    }
---------------------------------------------------------------
    // finally不一定要写
	try {
       
    } catch (可能出现的异常类型 变量名) {

    } finally {

    }
----------------------------------------------------------------
   	// catch可以出现多次，捕获多个异常
	try {
        
    } catch (可能出现的异常类型 变量名) {

    } catch (可能出现的异常类型 变量名) {

    } finally {

    }

例子

package October_12;

import org.junit.Test;

public class a {
    @Test
    public void test1() {
        String str = "abc";
        try {
            int num = Integer.parseInt(str);
        } catch (NumberFormatException numberFormatException) {
            System.out.println("出现异常");
        }
    }
}

结果：

出现异常

说明
1. finally是可选的
2. 使用try将可能出现的异常的代码装起来，在try执行过程中，一旦出现异常就会停止运行，生成对应的异常类的对象
3. 根据生成的异常类对象的类型，去catch中进行匹配。
4. 一旦try中的异常对象匹配到某个catch时，就进入catch中进行异常的处理。处理完成就跳出try——catch结构（没有finally），继续后续代码的运行。
5. catch中的异常类型如果满足子父类的关系，子异常catch需要在父类catch之前声明，否则会报错。
  
  不满足子父类关系，声明顺序没有影响。
6. 常用的异常对象处理的方式
  1. String getMessage() —— 展示错误信息
  2. printStackTrace() —— 展示错误类型和错误信息
7. try结构中声明的变量不能被任何其他结构或结构外调用。就连catch都不可以调用声明在try里面的变量。如果想用try中的变量，可以将变量的声明放在try结构并且初始化。
```
package October_12;

import org.junit.Test;

public class a {
    @Test
    public void test1() {
        String str = "abc";
        int num = 0;		// 声明在外并初始化
        try {
             num = Integer.parseInt(str);
            // 可能出现异常的代码
            System.out.println(str);
        } catch (NumberFormatException numberFormatException) {
            System.out.println("出现异常");
        }

        System.out.println(num);
    }
}
```
8. finally段中的代码是一定会被执行的，无论try中是否有错误或者catch是否发现错误。
```
package October_13;

import org.junit.Test;

public class a {
    @Test
    public void test1() {
        System.out.println(test2());
    }

    public int test2() {
        try {
            int a = 10;
            int b = 0;
            return a / b;
        } catch (ArithmeticException ae) {
            ae.printStackTrace();
            return 2;
        } finally {
            System.out.println("3");
            // return 3;
        }
    }
}
```
  finally是一定会被执行的代码。如上例，在finally结构中直接 return，将会结束代码直接返回。
9. 像数据库连接、输入输出流、网络编程Socket等资源，JVM是不能自动的回收的，我们需要自己手动的进行资源释放。此时的资源释放，就需要声明在finally中。
10. try —— catch —— finally 可以嵌套
```
try {

} catch () {

}finally {
    // finally内有一个try —— catch
    try {

    } catch () {

    }
}
```
11. 处理编译异常是让程序在编译时不出现异常，但是运行时仍可能出现异常。相当于将编译异常延时带运行的时候出现。
12. 运行异常较为常见，出错的机会大，角度刁钻，所以通常不对运行时异常做处理。但针对于编译时异常，一定要考虑异常处理。

2. throws + 异常类型

”throws + 异常类型“写在方法的声明处，指定在此方法被调用执行可能会出现的异常。

一旦方法被调用执行，如果出现异常，就会在异常处生成一个异常类的对象，此对象满足thows后异常类型时，就会被抛出。异常代码的后续代码将不再执行。

package October_13;

public class test {

    public static void main(String[] args) {
        try {
            t2();
        } catch (Exception e) {
            e.printStackTrace();
            // 调用方法需要处理异常。
            System.out.println("异常出现");
        }
    }

    public static void t2() throws Exception {
        t1();
    }

    public static void t1() throws NumberFormatException {
        String str = "abc";
        int num = Integer.parseInt(str);
        // 可能出现异常的代码
        System.out.println("出现异常后续不会继续执行代码");
    }
}

结果：

错误
异常出现

3. 总结

try —— catch —— finally 是真正的解决异常
”throws + 异常类型“ 是提醒调用者可能会出现什么异常

try —— catch —— finally & throws + 异常类型

异常的处理

1. try —— catch —— finally

2. throws + 异常类型

3. 总结