「JAVA」详述Java异常体系，处理异常时配上finally效果更佳

时间 2020-07-06

标签 java 详述异常体系处理配上 finally 效果更佳栏目 Java 繁體版

原文原文链接

什么是异常

从事Java开发的小伙伴对于“异常”应该不陌生，由于天天都会遇到很多异常，或捕获，或抛出。那究竟什么是异常？异常即非正常的，不一样于日常、通常化的状况。在平时生活中，医生会说你身体的某个部位有异常，该异常会有什么什么的影响，是由某某缘由引发的；我天天都准时打卡，按时上下班，那么我本月的考勤是正常的，反之，但凡是有迟到、旷工、早退的状况之一的，我本月的考情就会有异常。java

而在程序中，代码在运行中若是出现运行错误，程序会终止运行，这时因为错误致使程序运行终止的状况就是程序出现了异常。异常并非指语法错误，由于若是语法错了，编译就通不过，不会产生JVM可以识别的字节码文件，是无法运行起来的，因此只有运行中的程序才会有异常一说。程序员

Java 异常体系

异常处理是衡量一门语言是否成熟的标准之一，C系列的语言诸如：Java、C++、C 等都支持异常处理，有本身的一套异常处理机制。异常处理机制可让程序有更好的容错性，使代码更加健壮；但C语言却没有异常处理机制，C程序员通常都是利用方法的返回值来实现异常处理，使用 if + 条件 来判断正常和异常状况，使用特定返回值来表示异常状况。数据库

引入异常处理机制能够解决的问题有：数组

使用方法的返回值来表示异常状况有局限性，须要无穷列举全部的异常状况；
异常流程代码和正常流程代码混合一块儿，代码每每很臃肿，也很复杂性；代码的可读性和可维护性都不高；
随着系统规模的不断扩大，代码很难维护，特别是系统可拓展性差；

经过一下这个案例来讲明引入异常以前的处理方式：网络

// 汽车
class Car {    
    // 汽车是否正常运行    
    public static final boolean IS_OK = true;    

    // 汽车运行    
    public boolean run(int wheelNum) {        
        if (wheelNum == 4) {           
            return true;        
        }        
        return false;     
    }
}

// 上班族
class Officer {    
    private Car car;    
    public Officer(Car car) {       
         this.car = car;    
    }    
    
    // 开车去上班    
    public boolean goWorkByCar(int wheelNum) {       
           if (car == null) {            
                  // 只能选择其余出行方式了            
                  goWorkByOther();            
                  return false;        
            }        
            boolean result = car.run(wheelNum);        
            if (result) {            
                 System.out.println("升职，加薪，迎娶白富美");            
                 return true;        
            }        
            System.out.println("迟到，扣薪，领导每天喷");        
            return false;    
      }    
      // 其余方式上班    
      public void goWorkByOther() {        
            System.out.println("其余方式上班");    
      }
}
      
// 运行demo
public class WorkDemo {    
      public static void main(String[] args) {        
              Car car = new Car();        
              Officer officer = new Officer(car);        
              officer.goWorkByCar(4);    
      }
}

上述案例中，只是简单粗暴的把汽车的状态分为true和false两种，细化不够，不能体现出汽车的详细状态；业务逻辑也很局限，若是要拓展，就要花费更大的成本。ide

针对于上述的问题，Java基于面向对象的思想提出了解决方案：性能

把不一样类型的异常状况使用不一样的类来表示，不一样的异常类有共同的父类；
分离异常流程代码和正确流程代码；
规范了异常处理机制，灵活处理异常，能处理就将其捕获并处理，若是处理不了异常，就将其交给调用者来处理；

Java 异常体系：Java API文档中的详细介绍以下this

Error：表示错误，通常指JVM相关的不可修复的错误，如：系统崩溃、内存溢出、JVM内部错误等，由JVM抛出，咱们通常状况下不须要处理，几乎其全部的子类都是以“Error”做为类名后缀；好比：StackOverflowError，当应用程序递归太深而发生内存溢出时，就会抛出该错误。
Exception：表示异常，指程序中出现不正常的状况，异常通常都是须要程序员来处理的（能够捕获或者抛出）；几乎其全部的子类都是以“Exception”做为类名的后缀；
Throwable：在Java 体系中，Throwable类是全部错误和异常的父类；

当出现了没见过的异常时，能够将异常类的类名拿到Java API文档中去查找，经过文章介绍便可得到异常的详细信息，以及其在Java中的继承、实现体系；常见的Exception有：spa

NullPointerException：空指针异常，通常当对象为null的时候，对该对象作操做时会出现该异常；
ArrayIndexOutOfBoundsException：数组的索引越界，操做数组时使用的索引超出了数组的数据范围会出现；
NumberFormatException：数字格式化异常，把非数字的数据类型转换为数字类型时使用了非法的转换对象；

Java 的异常详解：3d

public class ExceptionDemo {    
     public static void main(String[] args) {        
        Integer.valueOf("laofu");    
     }
}

运行结果以下：

若是出现异常，会马上中断运行中的程序，因此必须处理异常，而处理方式有两种：

throws：当前方法不处理，而是声明抛出，由该方法的调用者来处理；
try-catch：在当前方法中使用try-catch的语句块来处理异常；

捕获异常 try-catch

出现异常以后，程序会中断执行，因此异常必须处理；处理的方式有两种：捕获和抛出，两种方式二选一便可。咱们先来运行一个案例来证实：

public static void main(String[] args) {        
    System.out.println("老夫开始啦");        
    int result = 10 / 2;        
    System.out.println("10 / 2 = " + result);        
    System.out.println("老夫去也");
}

运行结果以下：

老夫开始啦
10 / 2 = 5
老夫去也

经过查看运行结果，是咱们指望的运行结果，代码运行成功；那么接下来咱们对上述案例稍做修改，再来看其运行结果如何：

public static void main(String[] args) {        
    System.out.println("老夫开始啦");        
    int result = 10 / 0;        
    System.out.println("10 / 2 = " + result);        
    System.out.println("老夫去也");   
 }

运行结果以下：

老夫开始啦
Exception in thread "main" java.lang.ArithmeticException: / by zero    
            at Main.main(Main.java:5)

经过查看运行结果，运行结果并非咱们想要的，代码中出现了异常，代码被中断运行。对比两次的运行结果，咱们能够得出结论：出现异常以后，程序会中断执行，异常必须处理。

try-catch 异常捕获：使用try-catch捕获单个异常，语法以下：

try{     
    编写可能会出现异常的代码
} catch(异常类型  e) {     
    处理异常的代码     
    //记录日志/打印异常信息/继续抛出异常
}

注意：try和catch都不能单独使用，必须连用

因此能够对上述出现异常的代码使用try-catch来处理：

public class ExceptionDemo {    
    public static void main(String[] args) {        
        System.out.println("老夫开始啦");        
        try {          
            int result = 10 / 0;          
            System.out.println("10 / 2 = " + result);        
        } catch (ArithmeticException e) {          
            System.out.println("异常信息：" + e.getMessage()); 
            System.out.println("异常对象：" + e.toString());  
            System.out.println("异常栈追踪：");          
            e.printStackTrace();        
        }        
        System.out.println("老夫去也");        
    }
}

运行结果以下：

老夫开始啦异常信息：/ by zero
异常对象：java.lang.ArithmeticException: / by zero
异常栈追踪：老夫去也java.lang.ArithmeticException: / by zero    
                  at Main.main(Main.java:6)

经过查看运行结果，不难发现，使用try-catch以后，程序遇到异常时再也不中断执行，而是跳过异常代码及其以后的在try-catch中的剩余代码语句，来到catch代码块中执行咱们定义的异常处理代码；

在上述案例中是打印出了异常信息，异常对象信息，异常栈追踪；其中的3个方法都是Throwable类的方法：

String getMessage()：获取异常的详细描述信息；
String toString()：获取异常的类型、异常描述信息；
void printStackTrace()：打印异常的跟踪栈信息并输出到控制台，但不能在System.out.println()中使用该方法；其中包含了异常的类型、异常的缘由、异常出现的位置；在开发和调试阶段，该方法都颇有用，方便调试和修改；

使用try-catch捕获多个异常：语法以下：

try{     
    编写可能会出现异常的代码
} catch (异常类型A  e){  // 当try中出现A类型异常,就用该catch来捕获.
    处理异常的代码    
    //记录日志/打印异常信息/继续抛出异常
} catch (异常类型B  e){  // 当try中出现B类型异常,就用该catch来捕获.    
   处理异常的代码     
    //记录日志/打印异常信息/继续抛出异常
}

注意

一个catch语句，只能捕获一种类型的异常，若是须要捕获多种异常类型，就得使用多个catch语句；
try-catch中的代码在只会出现一种类型的异常，只能一个catch捕获，不可能同时匹配多个catch；
在有多个catch语句的代码中出现异常时，会从上到下依次匹配catch语句，因此多个catch语句应该按照从子类到父类的顺序依次定义；
一旦匹配上其中一个catch以后，便不会匹配剩余的catch，而是会跳出try-catch，执行以后的代码；

捕获多个异常的案例：

运行结果以下：

老夫开始啦
NumberFormatException
老夫去也
java.lang.NumberFormatException: For input string: "laofu"    
at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)    
at java.lang.Integer.parseInt(Integer.java:580)    
at java.lang.Integer.parseInt(Integer.java:615)    
at Main.main(Main.java:7)

抛出异常

抛出异常有两种方式：

throw：用于方法内部，用于给调用者返回一个异常对象，和return同样会结束当前方法；
throws：运用于方法声明之上，定义于方法参数以后，表示当前方法不处理异常，而是提醒该方法的调用者来处理抛出的异常(一个或者多个异常)；如：private static int divide(int num1, int num2) throws Exception {}

throw语句：运用于方法内部，抛出一个具体的异常对象，停止方法的执行，其语法格式以下：

throw  new  异常类("异常信息");

通常的，当一个方法出现异常的状况，咱们不知道该方法应该返回什么时，此时就能够返回一个错误，在catch语句块中使用throw继续向上抛出异常。return 是返回一个值，throw是返回一个错误，返回给该方法的调用者。好比：String类的charAt方法就是一个很好的例子：

throws：

若是每个方法都放弃处理异常都直接经过throws声明抛出，最后异常会抛到main方法，若是此时main方法还不处理，会继续抛出给JVM，JVM底层的处理机制就是打印异常的跟踪栈信息；runtime异常，默认就是这种处理方式。

方法重写(Override)中的throws：

一同：方法的签名必须相同。

两小：

子类方法返回类型和父类方法返回类型相同，或是其子类；
子类方法不能声明抛出新的异常；

一大：子类方法的访问权限必须大于等于父类方法的访问权限。

异常分类

异常(Exception)根据其在编译时期仍是运行时期去检查异常可分为：checked异常和runtime异常，

runtime异常：又称运行时期异常，此类型的异常在运行时期检查；在编译时期，运行异常并不会检测，就不会出现，只有在运行到相关代码时才会出现；RuntimeException自身及其子类异常都属于runtime异常；
checked异常：又称编译时期异常，此类型的异常在编译时期就会检查，并且是必须处理的，若是没有处理，就会致使编译失败；除了runtime异常以外的其余异常（包括Exception自身）都属于checked异常；