Java面向对象之异常【一】

目录

• Java面向对象之异常【一】
  • 异常的继承体系
    • Error
    • Exception
  • 异常是否受检
    • unchecked exceptions（不受检异常）
    • checked expections（受检异常)
  • 异常的处理方式
  • 自定义异常
  • 异常的捕获方式

Java面向对象之异常【一】

终于完成本学期的最后一门考试，考试周的我，边复习通讯之傅里叶变换，边学习Java的新知识。虽然好久没更，可是私底下的笔记满满，特意总结一波。
总结什么呢？异常！嗯？异常？最近却是人有些异常……复习到一两点，早上早早起来刷题，不异常才怪。异常嘛，很好理解，就是本该正常的事情出了问题嘛。
这时咱们回想咱们以前写过一个再简单不过的例子：计算两个整数相除。二话不说，直接就能够写出以下代码，对吧。

public static void main(String[] args) {
    Scanner input = new Scanner(System.in);
    System.out.println("Enter two integers: ");
    int num1 = input.nextInt();
    int num2 = input.nextInt();
    System.out.println(num1 / num2);
}

这短短的代码中就存在着隐患，而这个隐患有可能就会演变成异常。什么状况呢？咱们知道，在Java的整数计算中，若是除数为零，计算式将会是没有任何意义的。带着咱们的猜测，编译运行，不出所料，它飘红了。

因而，咱们对红字进行分析，得出结论：一个名为ArthmeticException的异常在执行main方法的第17行时发生：除数为零。清清楚楚，明明白白。
能够看到，异常一旦发生，程序就将终止，并且这种抛出异常的机制，可以让咱们有效地找到问题所在，并及时解决问题。异常机制的存在，就是为了更好地解决问题，保证程序的健壮性。
因此，咱们试图修改代码，让它在方法中实现：

public static int quotient(int num1, int num2) throws ArithmeticException{
    if (num2 == 0) {
        throw new ArithmeticException("Divisor can not be zero");
    }
    return num1 / num2;
}

在main方法中调用查看结果：

int num1 = input.nextInt();
int num2 = input.nextInt();
try {
    System.out.println(QuotientWithMethod.quotient(num1, num2));
}catch (ArithmeticException e) {
    System.out.println(e.getMessage());
}

继续测试（固然为了测试，咱们这里抛出了一个运行时异常，本能够不抛）：

• 在求两数之商的方法中主动抛出（throw）一个异常，throw new ArithmeticException("Divisor can not be zero");对象。
• 在方法定义处声明方法将会抛出的异常类型，throws ArithmeticException。
• 在调用该方法时捕获方法，try{...}catch (ArithmeticException e){...}并执行咱们但愿处理异常的语句，System.out.println(e.getMessage());。

固然，上述的例子集抛出异常、声明异常及处理异常于一身，可是异常的内容可不只仅是这么简单，咱们在以后的内容中来探一探异常的究竟：

异常的继承体系

先来看一下异常的类继承图，当是不彻底统计的，由于还有还多好多的异常等待着被探索。

经过图片咱们能够明显的发现，这些异常的命名很是好认，果然见名知义。Throwable是全部异常的顶级父类，在它的下面有两个大类：Exception和Error。下面是官方文档对二者进行的解释：

Error

• 合理的应用程序出现的不该该捕获的严重问题 ，合理指的是语法和逻辑上。

• 不能处理，不要尝试用catch捕获，只能尽可能优化。
• 它及它的子类异常不须要在throws语句中声明，不须要说明他们将会被抛出。
• 它们属于不受检异常（unchecked exceptions）。

• 与虚拟机相关，如系统崩溃、虚拟机错误、动态连接失败等

Exception

• 与Error不一样的是，Exception表明的是一类在合理的应用程序中出现的能够处理的问题。
• 除了特例RuntimeException及其子类以外，Exception的其余异常子类都是受检异常（checked exceptions）。

异常是否受检

unchecked exceptions（不受检异常）

也叫运行时异常，由Java虚拟机抛出，只是容许编译时不检测，在没有捕获或者声明的状况下也同样可以经过编译器的语法检测，因此不须要去亲自捕获或者声明，固然要抛出该类异常也是能够的。典型的异常类型：Error及其子类异常，RuntimeException及其子类异常。注意：RuntimeException表明的是一类编程错误引起的异常：算数异常、空指针异常、索引越界异常、非法参数异常等等，这些错误若是代码编写方面没有任何漏洞，是彻底能够避免的，这也是不须要捕获或者声明的缘由，也有助于简化代码逻辑。

checked expections（受检异常)

也叫编译时异常，Java认为受检异常须要在编译阶段进行处理， 必须在显式地在调用可能出现异常的方法时捕获（catch），或者在声明方法时throws异常类型，不然编译不会经过。除了上面提到的Exception及其子类都属于受检异常，固然，不包括上面提到的RuntimeException。

异常的处理方式

咱们上面提到，咱们没法去直接处理不受检异常，可是咱们必须强制地对可能发生受检异常（编译时异常）的行为作处理，处理方法主要有如下：

• 在当前方法中不知道如何处理该异常时，直接在方法签名中throws该异常类型。

public void m1() throws ClassNotFoundException, IOException {
        //to do something
    }

• 在当前方法中明确知道如何处理该异常，就使用try{...}catch{...}语句捕获，并在catch块中处理该异常。

public void m3() {
        try {
            m1();
        } catch (ClassNotFoundException e) {
            //to do something
        } catch (IOException e) {
            //to do something
        }
    }

也能够直接捕获Exception的实例，由于它是这些异常的父类，可是上面的捕获异常引起的错误会更加直接一些。

public void m2() {
        try {
            m1();
        } catch (Exception e){
            //do something
        }
    }

若是处理不了，就一直向上抛，直到有完善解决的办法出现为止。固然咱们也能够自行抛出系统已经定义的异常：

public void m2(int i) throws IOException, ClassNotFoundException {
        if (i >1)
            throw new IOException("!");
        throw new ClassCastException();
    }

须要注意的是：

• 用throw语句抛出异常的实例！注意是异常的实例！且一次只能抛出一个异常！
• throw和throws是不同的！睁大眼睛！一个是抛出异常实例，一个是声明异常类型。
• 建立异常实例能够传入字符串参数，将被显示异常信息。

自定义异常

咱们知道，程序发生错误时，系统会自动抛出异常。那么，咱们若是想独家定制一个属于本身的异常能够不？答案显然是能够的，情人节快到了，直接自定义一个异常：

class noGirlFriendException extends Exception{
        noGirlFriendException(){
        }
        noGirlFriendException(String msg){
            super(msg);
        }
    }

须要注意的是：

• 若是自定义异常继承RuntimeException，那么该异常就是运行时异常，不须要显式声明类型或者捕获。
• 若是继承Exception，那么就是编译时异常，须要处理。
• 定义异常一般须要提供两个构造器，含参构造器传入字符串，做为异常对象的描述信息。

异常的捕获方式

• 每一个异常分别对应一个catch语句捕获。
• 对全部异常处理方式相同，用父类接收，向上转型,Exception对应的catch块应该放在最后面，否则的话，在他后面的块没有机会进入处理。下面就是一个典型的错误示范：

//下面的形式错误！
public static void main(String[] args) {
    try {
        System.out.println(1 / 0);
    } catch (Exception e) {
        e.printStackTrace();
    } catch (ArithmeticException e) {
        System.out.println(e.getMessage());
    }
}

• JDK1.7以后，能够分组捕获异常。
  • 异常类型用竖线分开。
  • 异常变量被隐式地被final修饰。

try {
    System.out.println(1 / 0);
} catch (ArithmeticException | NullPointerException e) {
    //捕获多异常时，异常变量被final隐式修饰
    //！false: e = new ArithmeticException();
    System.out.println(e.getMessage());
}

本文参考诸多资料，并加上自身理解，若有叙述不当之处，还望评论区批评指正。关于异常，还有一部份内容，下篇进行总结，晚安。
参考资料：
https://stackoverflow.com/questions/6115896/understanding-checked-vs-unchecked-exceptions-in-java

https://www.programcreek.com/2009/02/diagram-for-hierarchy-of-exception-classes/

https://stackoverflow.com/search?q=%5BJava%5D+Exception