Java基础——Java异常机制

1.Java异常关键字

try{}           有可能出现异常的代码

catch{}      根据try{}语句块中的异常和()中的异常来进行处理，可写多个catch

finally{}     不管是否发生异常，都会执行的语句块

throw        使用throw关键字从方法中跑出一个异常，抛给方法本身

throws      将方法的异常抛给调用者

示例：

表示抛强制异常异常的两种方式

1、快捷键option/alt + 回车；2、在方法后面接上 —— throws InterruptedException

package com.java8.exception0823;

import java.io.File;
import java.io.IOException;

public class ExceptionTest {
    public static void main(String arg[]) throws InterruptedException {

        File file1 = new File("异常测试文件");

        //方法1：try{} catch{}
        try {
            System.out.println("try 1");
            file1.createNewFile();//IOException
            Thread.sleep(100);//InterruptedException
            int a = 10/0;//抛出除数为0的异常 ArithmeticException: / by zero
            System.out.println("try 2");
        }
        //catch可以有多个，针对try中不同的可能出现异常的函数，抛出不同的异常，变现为e不相同
        catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("catch 1:InterruptedException");
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("catch 2:IOException");
        } catch (Exception e){
            e.printStackTrace();
            System.out.println("catch 3:Exception");
        }
        //finally 无论如何都会执行
        finally {
            System.out.println("finally 1");
        }

        //方法2：在方法后面接上 —— throws InterruptedException
        System.out.println("try 3");
        Thread.sleep(1000);
        System.out.println("try 4");
    }
}

2.Java异常体系

Throwable类：

1 Error类       错误，代码无法解决的问题：栈溢出、...

2 Exception类   异常：对异常进行处理后，程序不会终止执行

3.异常的分类

 Exception

1 RuntimeException：运行时异常

 NullPointException：空指针

IndexOutOfBoundsException：数组越界

ClassCastException：类转换异常

ArithmeticException：除以0异常

2 强制异常：

IO、线程，如写一些函数时，出现红色波浪号，强制抛异常

4.抛出异常有三种形式

自动抛出:

当程序语句出现一些逻辑错误、主义错误或类型转换错误时，系统会自动抛出异常

int a = 10/0;
//抛出除数为0的异常 
//java.lang.ArithmeticException: / by zero

运行时，系统会抛出异常：

java.lang.ArithmeticException: / by zero
    at com.java8.exception0823.ExceptionTest.main(ExceptionTest.java:21)

throw：

语句抛出一个异常，一般是在代码块的内部，当程序出现某种逻辑错误时由程序员主动抛出某种特定类型的异常

        int testThrow = 0;
        if(testThrow==0){
            throw new NumberFormatException();
        }

运行时，系统会抛出异常：

Exception in thread "main" java.lang.NullPointerException
    at com.java8.exception0823.ExceptionTest.main(ExceptionTest.java:13)

throws：

throws是方法可能抛出异常的声明。(用在声明方法时，表示该方法可能要抛出异常)

public void function() throws Exception{......}

当某个方法可能会抛出某种异常时用于throws 声明可能抛出的异常，然后交给上层调用它的方法程序处理

package com.java8.exception0823;

public class TestThrows {

    //必须加上static
    public static void function() throws NumberFormatException{
        String name = "iris";
        Double.parseDouble(name);
    }
    public static void main(String[] arg){
        try{
            function();
        }catch(NumberFormatException e){
            System.err.println("非数据类型不能强制类型转换。");
        }
    }

运行时，系统输出：

非数据类型不能强制类型转换。

5.程序出现异常解决办法

    step1：确定异常类型
    step2：从异常堆栈信息找到自己写的类（多个）
    step3：找到最终的出异常的类
    step4：System.out.println()输出信息；
                Debug模式。

6.throw与throws的比较

1、throws出现在方法函数头；而throw出现在函数体。
2、throws表示出现异常的一种可能性，并不一定会发生这些异常；throw则是抛出了异常，执行throw则一定抛出了某种异常对象。
3、两者都是消极处理异常的方式（这里的消极并不是说这种方式不好），只是抛出或者可能抛出异常，但是不会由函数去处理异常，真正的处理异常由函数的上层调用处理。

7.编程习惯

1.在写程序时，对可能会出现异常的部分通常要用try{...}catch{...}去捕捉它并对它进行处理；
2.用try{...}catch{...}捕捉了异常之后一定要对在catch{...}中对其进行处理，那怕是最简单的一句输出语句，或栈输入e.printStackTrace();
3.如果是捕捉IO输入输出流中的异常，一定要在try{...}catch{...}后加finally{...}把输入输出流关闭；
4.如果在函数体内用throw抛出了某种异常，最好要在函数名中加throws抛异常声明，然后交给调用它的上层函数进行处理。

ps.快捷键

IDEA抛异常快捷键：alt/option + command + T 、 alt + enter

自动格式化代码：ctrl + alt + L