错误和异常

异常就是指程序在执行的过程中出现的非常情况，最终导致JVM非正常停止。

在Java中，提供了Throwable类用于处理异常，其子类Error类用于处理错误、Exception类用于处理异常。

Error类用于处理严重错误或无法处理的错误，只能事先避免，比如内存溢出等。

Exception类，称为异常类，它表示程序本身可以处理的问题，比如数组下标越界等。

异常分类

异常可分为两大类：编译时异常和运行时异常。

编译时异常也称为检查异常，必须显示处理，否则程序不能通过编译，更不能正常运行了。

运行时异常也称为非检查异常，无需显示处理，但在出现问题后，需要我们修改代码。

RuntimeException所有的类及其子类被称为运行时异常，其它的异常都是编译时异常。

异常处理的机制

当程序中抛出一个异常后，从而导致程序在异常的代码处跳出，JVM检测寻找与try匹配的处理异常的catch块。如果找到，将控制权交给catch块中的代码，然后继续执行程序，try块中发生异常的代码不会被重新执行。否则程序会在运行时报错。

try-catch

语法格式：

try {
    // todo 可能出现异常
} catch(<Exception class>) {    // 捕获何种异常
    // todo 异常处理
}

例如：

        try {
            int i = 9/0;
        } catch (RuntimeException e) {
            System.out.println("RuntimeException: " + e);
        }

执行流程：

• 程序从try块里面的代码开始执行
• 当执行过程中出现异常，会自动生成一个异常类对象，该异常对象将被提交给Java运行时系统
• 当Java运行时系统接收到异常对象时，会到catch块中查找匹配的异常类，找到后进行异常的处理
• 执行完毕后，程序还可以继续往下执行

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

捕获的异常类型按照由上至下的顺序在catch块查找匹配，即应按照子类到父类的顺序书写catch块。

例如：

        try {
            int i = 9/0;
        } catch (NullPointerException e) {
            System.out.println("NullPointerException: " + e);
        } catch (RuntimeException e) {
            System.out.println("RuntimeException: " + e);
        } catch (Exception e) {
            System.out.println("Exception: " + e);
        }

finally

finally语句为异常处理提供一个统一的出口，使得在控制流程到程序其它部分之前，能够对程序的状态作统一的管理。

无论try所指的程序块中是否抛出异常，finally块都会被执行。因此可以在finally块中进行资源的释放处理。比如关闭打开的文件、关闭数据库连接等。

语法：

try {
    // todo 可能出现异常
} catch(<Exception class>) {    // 捕获何种异常
    // todo 异常处理
} finally {
    // todo 收尾处理
}

例如：文件读取

        BufferedReader br = null;
        try {
            br = new BufferedReader(new InputStreamReader(new FileInputStream("readme.txt")));
            String line = "";
            while ( (line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (FileNotFoundException e) {
            System.out.println("FileNotFoundException: " + e);
        } catch (IOException e) {
            System.out.println("IOException: " + e);
        } finally {
            if(null != br) {
                try {
                    br.close();
                } catch (IOException e) {
                    br = null;
                }
            }
        }
    }

需要注意的是finally不能单独使用，必须和try-catch配合使用。

throws & throw

程序中会声明很多方法，这些方法中可能会因为某些错误而引发异常，但不希望直接在这个方法中处理这些异常，而希望调用它的方法统一处理，这时候就需要使用throws关键字在这个方法上声明异常。

例如：

    public void calc() throws ArrayIndexOutOfBoundsException {
        int[] arrs = new int[3];
        arrs[3] = 0;
    }

throws可以声明多个异常，使用逗号分隔。例如：

public void calc() throws ArrayIndexOutOfBoundsException, RuntimeException {
    int[] arrs = new int[3];
    arrs[3] = 0;
}

在处理异常时，可使用try-catch，也可以使用throws。如果使用throws方案，将来谁调用谁来处理异常。

当程序发生错误而无法处理的时候，会抛出对应的异常对象，除此之外，在某些时候，还需要自行抛出异常，此时就需要用到throw关键字，并生成指定的异常对象后抛出。

throw是在方法体内定义，用来抛出一个异常对象。语法为：

throw new <异常对象>

例如：

throw new RuntimeException();

throw 和 throws的区别

• throw用在方法体内，后面跟异常对象表示抛出异常，由方法体内的语句处理执行throw一定是抛出了某种异常
• throws用在方法声明之后，跟的是异常类名表示抛出异常，由该方法的调用者来处理表示出现异常的一种可能性，并不一定会发生这些异常

构造函数中使用throws抛出异常

在父类构造函数中使用throws抛出异常时

• 子类构造方法中throws抛出的异常必须大于等于父类throws抛出的异常，并且只能抛出不能捕获。
• 子类构造方法中也可以不声明异常

例如：

class Father {
    public Father() throws NullPointerException {

    }
}

• 抛出和父类一样的异常

class Son1 extends Father{

    public Son1() throws NullPointerException {
    }
}

• 抛出大于父类的异常

class Son2 extends Father {

    public Son2() throws RuntimeException {
    }
}

• 不抛出异常

class Son3 extends Father {
    public Son3() {
    }
}

方法重写时使用throws关键字

使用继承时，在父类某个方法上声明了异常，子类重写这个方法时，可分为以下几种使用方式

class Father {

    public void show() throws IllegalArgumentException, NullPointerException {

    }
}

• 不处理异常

class Son extends Father {
    @Override
    public void show() {

    }
}

• 可仅抛出父类声明的部分异常

class Son extends Father {
    @Override
    public void show() throws IllegalArgumentException {

    }
}

• 子类抛出的异常要小于或者等于父类抛出的异常

class Son extends Father {
    @Override
    public void show() throws NumberFormatException {

    }
}

• 子类重写父类时抛出运行时异常，那么父类被重写的方法上可以不抛出异常

class Father {

    public void show() {

    }
}

class Son extends Father {
    @Override
    public void show() throws NumberFormatException {

    }
}

• 如果方法没有抛出异常，子类重写父类该方法时抛出异常，那么会报编译错误，此时解决该问题的方法有两种：父类被重写的方法上抛出的异常要大于或者等于子类方法抛出的异常

class Father {

    public void show() throws ParseException {

    }
}

class Son extends Father {
    @Override
    public void show() throws NumberFormatException {

    }
}

子类方法中直接捕获异常，不抛出

class Father {

    public void show() {

    }
}

class Son extends Father {
    @Override
    public void show() {

        try {
            String str = "ijunfu";
            NumberFormat.getInstance().parse(str);
        } catch (ParseException e) {
            e.printStackTrace();
        }

    }
}

RuntimeException和自定义异常

RuntimeException 常用子类

• NullPointerException当应用程序视图在需要对象的地方使用null时，抛出该异常
• ArrayIndexOutOfBoundsException当使用的数组下标超出数组允许范围时，抛出该异常
• ClassCastException当视图将对象强制转换为不是实例的子类时，抛出该异常
• NumberFormatException当应用程序视图将字符串转换称为一种数值类型时，但该字符串不能转换为恰当的格式时，抛出该异常

Exception常用API

• printStackTrace()打印出堆栈内的错误信息，常用于跟踪异常事件
• getMessage()从堆栈中获取错误信息

自定义异常

异常机制可以保证程序更安全和更健壮。虽然类库已经提供很多可以直接处理异常的类，但是有时候为了更加准确地捕获和处理异常已呈现更好的用户体验，需要开发者自定义异常。

例如：

class MyException extends Exception {
    public MyException(String message) {
        super(message);
    }
}