Java异常处理

时间 2020-01-19

标签 java 异常处理栏目 Java 繁體版

原文原文链接

1，异常现象

程序错误分为三种：1，编译错误；2，运行时错误；3，逻辑错误。
  编译错误是由于程序没有遵循语法规则，编译程序可以本身发现而且提示咱们错误的缘由和位置，这个也是你们在刚接触编程语言最常遇到的问题。
  运行时错误是由于程序在执行时，运行环境发现了不能执行的操做。
  逻辑错误是由于程序没有按照预期的逻辑顺序执行。异常也就是指程序运行时发生错误，而异常处理就是对这些错误进行处理和控制。

2，java异常类

Java异常类层次结构图：
java

在 Java 中，全部的异常都有一个共同的祖先java.lang包中的 **Throwable类**。Throwable： 有两个重要的子类：**Exception（异常）**和 **Error（错误）**，两者都是 Java 异常处理的重要子类，各自都包含大量子类。

Error（错误）:是程序没法处理的错误，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操做无关，而表示代码运行时 JVM（Java 虚拟机）出现的问题。例如，Java虚拟机运行错误（Virtual MachineError），当 JVM 再也不有继续执行操做所需的内存资源时，将出现 OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）通常会选择线程终止。程序员

这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时，如Java虚拟机运行错误（Virtual MachineError）、类定义错误（NoClassDefFoundError）等。这些错误是不可查的，由于它们在应用程序的控制和处理能力之外，并且绝大多数是程序运行时不容许出现的情况。对于设计合理的应用程序来讲，即便确实发生了错误，本质上也不该该试图去处理它所引发的异常情况。在 Java中，错误经过Error的子类描述。面试

Exception（异常）:是程序自己能够处理的异常。Exception 类有一个重要的子类 RuntimeException。RuntimeException 异常由Java虚拟机抛出。NullPointerException（要访问的变量没有引用任何对象时，抛出该异常）、ArithmeticException（算术运算异常，一个整数除以0时，抛出该异常）和 ArrayIndexOutOfBoundsException （下标越界异常）。数据库

注意：异常和错误的区别：异常能被程序自己能够处理，错误是没法处理。编程

一般，Java的异常(包括Exception和Error)分为可查的异常（checked exceptions）和不可查的异常（unchecked exceptions）。数组

可查异常（编译器要求必须处置的异常）：正确的程序在运行中，很容易出现的、情理可容的异常情况。可查异常虽然是异常情况，但在必定程度上它的发生是能够预计的，并且一旦发生这种异常情况，就必须采起某种方式进行处理。安全

除了RuntimeException及其子类之外，其余的Exception类及其子类都属于可查异常。这种异常的特色是Java编译器会检查它，也就是说，当程序中可能出现这类异常，要么用try-catch语句捕获它，要么用throws子句声明抛出它，不然编译不会经过。微信

不可查异常(编译器不要求强制处置的异常)：包括运行时异常（RuntimeException与其子类）和错误（Error）。编程语言

Exception 这种异常分两大类运行时异常和非运行时异常(编译异常)。程序中应当尽量去处理这些异常。学习

运行时异常：都是RuntimeException类及其子类异常，如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等，这些异常是不检查异常，程序中能够选择捕获处理，也能够不处理。这些异常通常是由程序逻辑错误引发的，程序应该从逻辑角度尽量避免这类异常的发生。

运行时异常的特色是Java编译器不会检查它，也就是说，当程序中可能出现这类异常，即便没有用try-catch语句捕获它，也没有用throws子句声明抛出它，也会编译经过。

非运行时异常（编译异常）：是RuntimeException之外的异常，类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常，若是不处理，程序就不能编译经过。如IOException、SQLException等以及用户自定义的Exception异常，通常状况下不自定义检查异常。

Trowable类经常使用方法：

public string getMessage():返回异常发生时的详细信息
public string toString():返回异常发生时的简要描述
public string getLocalizedMessage():返回异常对象的本地化信息。使用Throwable的子类覆盖这个方法，能够声称本地化信息。若是子类没有覆盖该方法，则该方法返回的信息与getMessage（）返回的结果相同
public void printStackTrace():在控制台上打印Throwable对象封装的异常信息

Java常见异常

1. runtimeException子类:

一、 java.lang.ArrayIndexOutOfBoundsException

    数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。

    二、java.lang.ArithmeticException

    算术条件异常。譬如：整数除零等。

    三、java.lang.NullPointerException

    空指针异常。当应用试图在要求使用对象的地方使用了null时，抛出该异常。譬如：调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等

    四、java.lang.ClassNotFoundException

    找不到类异常。当应用试图根据字符串形式的类名构造类，而在遍历CLASSPAH以后找不到对应名称的class文件时，抛出该异常。

   五、java.lang.NegativeArraySizeException  数组长度为负异常

   六、java.lang.ArrayStoreException 数组中包含不兼容的值抛出的异常

   七、java.lang.SecurityException 安全性异常

   八、java.lang.IllegalArgumentException 非法参数异常

2.IOException

IOException：操做输入流和输出流时可能出现的异常。

EOFException   文件已结束异常

FileNotFoundException   文件未找到异常

3. 其余

ClassCastException    类型转换异常类

     ArrayStoreException  数组中包含不兼容的值抛出的异常

     SQLException   操做数据库异常类

     NoSuchFieldException   字段未找到异常

     NoSuchMethodException   方法未找到抛出的异常

     NumberFormatException    字符串转换为数字抛出的异常

     StringIndexOutOfBoundsException 字符串索引超出范围抛出的异常

     IllegalAccessException  不容许访问某类异常
     
     InstantiationException  当应用程序试图使用Class类中的newInstance()方法建立一个类的实例，而指定的类对象没法被实例化时，抛出该异常

3,异常处理方法

在 Java 应用程序中，异常处理机制为：抛出异常，捕捉异常。

1，声明和抛出异常

任何代码都有可能发生系统错误（Error）和运行时错误（RunrimeException），所以在方法声明时，Java系统不要求显示的声明Error和RuntimeException两种异常类（系统隐含的声明了这两种异常类），可是，能够在方法体中抛出这两种异常对象。须要注意的是：若是要在方法体中抛出其它异常，必须在方法头声明这种异常类。
，声明异常类的格式：
在方法头中使用throws关键字，例如：
public void myThod throws IOException //这里声明的异常类是：IOException.
关键字throws指出方法myThod在执行时可能抛出IOException异常（对象）。若是方法执行时可能抛出多种异常，就能够像实现多个接口的同样，将异常类之间用逗号隔开，例如：
public void myThod throws Exception1， Exception2....... ExceptionnN
抛出异常对象的格式
在方法头中声明了异常类后，就应该在方法体中抛出一个与方法头名中声明的异常类相一致的对象。例如：
Throw new TheException();//抛出异常
或
TheException ex=new TheException();
Throw ex;//抛出异常对象ex
注意：声明异常类的关键字是throws，抛出异常对象的关键字是throw

2，捕获和处理异常

1.try-catch语句

try {  
    // 可能会发生异常的程序代码  
} catch (Type1 id1){  
    // 捕获并处置try抛出的异常类型Type1  
}  
catch (Type2 id2){  
     //捕获并处置try抛出的异常类型Type2  
}

注意一个try语句后面能够跟不少catch语句，catch语句被称为异常处理器。关键词try后的一对大括号将一块可能发生异常的代码包起来，称为监控区域。Java方法在运行过程当中出现异常，则建立异常对象。将异常抛出监控区域之外，由Java运行时系统试图寻找匹配的catch子句以捕获异常。如有匹配的catch子句，则运行其异常处理代码，try-catch语句结束。

匹配的原则是：若是抛出的异常对象属于catch子句的异常类，或者属于该异常类的子类，则认为生成的异常对象与catch块捕获的异常类型相匹配
例1 捕捉throw语句抛出的“除数为0”异常。

public class TestException {  
    public static void main(String[] args) {  
        int a = 6;  
        int b = 0;  
        try { // try监控区域  
               
            if (b == 0) throw new ArithmeticException(); // “除数为0”等ArithmeticException，是RuntimException的子类。而运行时异常将由运行时系统自动抛出，不须要使用throw语句,这里把throw new ArithmeticException()去掉也是不影响运行结果的。
            System.out.println("a/b的值是：" + a / b);  
        }  
        catch (ArithmeticException e) { // catch捕捉异常  
            System.out.println("程序出现异常，变量b不能为0。");  
        }  
        System.out.println("程序正常结束。");  
    }  
}

运行结果：

　　在例1中  try监控区域经过if语句进行判断，当“除数为0”的错误条件成立时引起ArithmeticException异常，建立 ArithmeticException异常对象，并由throw语句将异常抛给Java运行时系统，由系统寻找匹配的异常处理器catch并运行相应异 常处理代码，打印输出“程序出现异常，变量b不能为0。”try-catch语句结束，继续程序流程。
 <font　color="#00BBFF"> 　　须要注意的是，一旦某个catch捕获到匹配的异常类型，将进入异常处理代码。一经处理结束，就意味着整个try-catch语句结束。其余的catch子句再也不有匹配和捕获异常类型的机会。</font>

Java经过异常类描述异常类型，异常类的层次结构如图1所示。对于有多个catch子句的异常程序而言，应该尽可能将捕获底层异常类的catch子句放在前面，同时尽可能将捕获相对高层的异常类的catch子句放在后面。不然，捕获底层异常类的catch子句将可能会被屏蔽。

RuntimeException异常类包括运行时各类常见的异常，ArithmeticException类和ArrayIndexOutOfBoundsException类都是它的子类。所以，RuntimeException异常类的catch子句应该放在最后面，不然可能会屏蔽其后的特定异常处理或引发编译错误。

2. try－catch-finally语句

try-catch语句还能够包括第三部分，就是finally子句。它表示不管是否出现异常，都应当执行的内容。try-catch-finally语句的通常语法形式为：

try {  
    // 可能会发生异常的程序代码  
} catch (Type1 id1) {  
    // 捕获并处理try抛出的异常类型Type1  
} catch (Type2 id2) {  
    // 捕获并处理try抛出的异常类型Type2  
} finally {  
    // 不管是否发生异常，都将执行的语句块  
}

例二，带finally子句的异常处理程序

public class TestException {  
    public static void main(String args[]) {  
        int i = 0;  
        String greetings[] = { " Hello world !", " Hello World !! ",  
                " HELLO WORLD !!!" };  
        while (i < 4) {  
            try {  
                // 特别注意循环控制变量i的设计，避免形成无限循环  
                System.out.println(greetings[i++]);  
            } catch (ArrayIndexOutOfBoundsException e) {  
                System.out.println("数组下标越界异常");  
            } finally {  
                System.out.println("--------------------------");  
            }  
        }  
    }  
}

运行结果：

小结：

try 块：用于捕获异常。其后可接零个或多个catch块，若是没有catch块，则必须跟一个finally块。
catch 块：用于处理try捕获到的异常。
finally 块：不管是否捕获或处理异常，finally块里的语句都会被执行。当在try块或catch块中遇到return语句时，finally语句块将在方法返回以前被执行。在如下4种特殊状况下，finally块不会被执行：
1）在finally语句块中发生了异常。
2）在前面的代码中用了System.exit()退出程序。
3）程序所在的线程死亡。
4）关闭CPU。

4，自定义异常类

虽然Java系统已经预约义好了不少异常类，可是有时会遇到预约义的异常类不能描述出现的错误。在这种状况下，程序员能够经过扩展Exception类及其子类来定义本身的异常类
格式以下

1.自定义异常:

class 异常类名 extends Exception 
{ 
    public 异常类名(String msg) 
    { 
        super(msg); 
    } 
}

2.标识可能抛出的异常:

throws 异常类名1,异常类名2

3.捕获异常:

try{} 
catch(异常类名 y){} 
catch(异常类名 y){}

4.方法解释

getMessage() //输出异常的信息
printStackTrace() //输出致使异常更为详细的信息
例子
CustomException.java

package me;

class FormatException extends Exception
{
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    private String ErrorMessage;
    public FormatException(String message)
    {
        super(message);
        ErrorMessage=message;
    }
    public String getMessage(){
        return "该数组元素"+ErrorMessage+"不是偶数，不符合";
    }
}
public class CustomException
{
    int A[]={6,7,3,2,5,1};
    public void g(int i)throws FormatException
    {
        System.out.println("一下输出数组元素偶数");
        for(i=0;i<=5;i++)
        {
            if(A[i]%2!=0)
            {
                throw new FormatException(String.valueOf(i));
                
            }
            else System.out.println("A["+i+"]="+A[i]);
        }
    }


public void run(int i){
    try{
        g(i);
    }
    catch(FormatException e)
    {
        e.getMessage();System.out.println(e);
    }
    finally{System.out.println("A["+i+"]="+A[i]);
}
}
}

text.java

package me;

public class Text {

    public static void main(String[] args)
    {
        CustomException a=new CustomException();
        a.run(5);
    }
    
}

运行结果：

欢迎关注个人微信公众号:"Java面试通关手册"（一个有温度的微信公众号，期待与你共同进步~~~坚持原创，分享美文，分享各类Java学习资源）：

Java异常处理

<font color="#66DD00">1，异常现象</font>

<font color="#66DD00">2，java异常类</font>

<font color="#99FF33">Trowable类经常使用方法：</font>

<font color="#99FF33">Java常见异常</font>

1. runtimeException子类:

2.IOException

3. 其余

<font color="#66DD00">3,异常处理方法</font>

<font color="#0044BB"> 1，声明和抛出异常</font>

<font color="#0044BB">2，捕获和处理异常</font>

<font color="#0066ff">1.try-catch语句<font>

<font color="#0066ff">2. try－catch-finally语句</font>

<font color="#0066ff">小结：<font>

<font color="#66DD00">4，自定义异常类</font>

1.自定义异常:

2.标识可能抛出的异常:

3.捕获异常:

4.方法解释