Java异常处理（附常见的异常）

一、异常概述
在编程中往往会出现这样或者那样的错误，这些错误就称之为异常

二、如何处理异常错误
如果在某个方法中抛出异常，既可以在当前方法中捕捉，然后处理该异常，也可以将异常向上抛出，由方法的调用者来处理

三、捕捉异常
Java语言的异常捕捉结构由try，catch和finally组成，其中try存放的是可能发生Java语句；catch程序块在try语句块之后，用来激发被捕获的异常；finally语句是异常处理结构最后一个部分，无论try块中的代码如何退出，都将执行finally块
语法：

try{
    //程序代码
}
catch(Exceptiontype1 e){
    //对Exceptiontype1 的处理
}
catch(Exceptiontype2 e){
    //对Exceptiontype2 的处理
}
......
finally{
    //程序块
}

1、try-catch语句

public class Take {
    public static void main(String[] args) {
        try {
            String str = "Iverson";
            System.out.print(str + "的age ");
            int age = Integer.parseInt("20L");
            System.out.println(age);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("End");
    }
}

结果是：

从上面的代码可以看出报的是NumberFormatException（字符串转换为数字）的错误，在最后的时候同样输出了End，说明Java的异常处理是结构化的，不会因为一个异常就影响整个程序的运行
注意：在catch语句中主要有以下几种函数来获取异常的相关信息
I、getMessage()函数：输出错误的性质
II、toString()函数：给出异常的类型和性质
III、printStackTrace()韩式：指出异常的类型，性质，栈层次及出现在程序中的位置
（一定不可以忽略这些函数，要不然出现错误是很难找到的）
2、finally语句块
一般而言，完整的异常处理语句一定要包含finally语句，无论程序有无异常发生，无聊了之间的try-catch语句是否顺利执行，都会执行finally语句，但是下面的4种情况是不会执行的
I、在finally语句块中出现异常
II、在前面的代码中使用了System.exit()退出程序
III、程序所在的线程死亡
IV、关闭了ＣＰＵ

四、Java常见的异常
ClassCastException:类型转换异常
ClassNotFoundException:未找到相应类异常
ArithmeticException:算数异常
ArrayIndexOutOfBoundsException:数组下标越界异常
ArrayStoreException：数组中包含不兼容的值抛出的异常
SQLException:操作数据库异常
NullPointerException:空指针异常
NoSuchFieldException:字段未找到异常
NoSuchMethodException：方法未找到异常
NumberFormartException：字符串转换为数字抛出的异常
NegativeArraySizeException：数组元素格式是负数抛出的异常
StringIndexOutOfBoundsException：字符串索引超出范围抛出的异常
IOException：输入输出异常
IllegalAccessException：不允许访问某类异常
InstantiationException：当应用程序试图使用Class类中的newInstance()方法创建一个类的实例，而指定的类对象无法被实例化时，抛出该异常
EOFException：文件已结束异常
FileNotFoundException：文件未找到异常

五、自定义异常
用户只需继承Exception类就可以自定义异常，步骤如下：
1、创建自定义异常类。
2、在方法中通过throw关键字抛出异常对象
3、如果在当前抛出异常的方法中处理异常，可以使用try-catch语句块捕获并处理，否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步的操作
先创建个MyException类

package com.example.exception;

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

再创建Tran类

package com.example.exception;

public class Tran {// 创建方法
    // 定义方法，抛出异常
    static int a(int no1, int no2) throws Exception {
        if (no1 > 10 || no2 > 10) {// 判断方法中参数是否满足指定条件
            throw new MyException("数值是大于10的");// 错误信息
        }
        return (no1 + no2) / 2;
    }

    public static void main(String[] args) throws Exception {
        try {
            int result = a(12, 13);// 调用a的方法
            System.out.println(result);// 将a的方法的返回值输出
        } catch (MyException e) {
            System.out.println(e);
        }
    }
}

运行结果是：

这就是自定义异常

六、在方法中抛出异常
1、使用throws关键字抛出异常
throws关键字通常被应用在声明方法时。用来指定方法可能抛出的异常，多个异常可以用“，”隔开

package com.example.exception;

public class Tran {// 创建方法
    // 定义方法，抛出异常
    static int a(int no1, int no2) throws Exception {
        if (no1 > 10 || no2 > 10) {// 判断方法中参数是否满足指定条件
            throw new MyException("数值是大于10的");// 错误信息
        }
        return (no1 + no2) / 2;
    }

    public static void main(String[] args) throws Exception {
        try {
            int result = a(12, 13);// 调用a的方法
            System.out.println(result);// 将a的方法的返回值输出
        } catch (MyException e) {
            System.out.println(e);
        }
    }
}

结果：

2、使用throw关键字抛出异常
throw关键字通常用于方法体中，并且抛出一个异常对象，程序在执行到throw语句时就立即终止，它后面的语句就不执行了，通过throw抛出异常后，如果想在上一级代码中捕获并处理异常，则就需要在抛出异常的方法中使用throws关键字在方法的声明中指明要抛出的异常，如果要捕捉throw抛出的异常就必须使用try-catch语句块
先创建个异常类:

package com.example.exception;

public class MyException extends Exception {
    String Message;

    public MyException(String Error) {
        Message = Error;
    }

    public String getMessage() {
        return Message;
    }
}

再编写Captor类

package com.example.exception;

public class Captor {//创建类
    static int q(int x, int y) throws MyException {//定义方法抛出异常
        if (y < 0) {//判断参数是否小于0
            throw new MyException("y不能为0");
        }
        return x + y;//返回值
    }

    public static void main(String[] args) {
        try {//try语句中包含可能出现异常的语句
            int result = q(2, -1);//调用q方法
        } catch (MyException e) {//处理自定义异常
            System.out.println(e.getMessage());//输出信息
        }

    }
}

结果：

这里要注意catch语句的顺序（见下面的例子）

try{
}
catch(MyException e){
//异常1
}
catch(ArithMeticException e){
//异常2
}
catch(Exception e){
//异常3
}

这里执行的顺序就是如果会发生异常1就到第一个的catch代码块中执行，同理，但是由于异常3是所有异常的父类，如果将这个放在最前面，后面就永远不能执行了，也就没什么意义了。

七、运行时的异常
运行时异常就是RuntimeException异常，在程序运行的过程中产生的异常，Java类库中的每个包都定义了异常类，所有的这些类都是ThrowTable类的子类，ThrowTable类派生了两个子类，分别是Exception和Error类，Error类及其子类是用来描述Java运行系统中的内部错误和资源耗尽的错误，这类错误比较严重，Exception类为非致命性类，可以 通过捕捉处理使程序继续执行，Exception类又根据错误发生的原因分为RuntimeException异常和除此之外的异常，一下的RuntimeException异常是可以通过try-catch语句捕获的。
NullPointerException：空指针异常
ArrayIndexOutOfBoundsException：数组 下标越界异常
ArithmeticException：算数异常
IllegalArgumentException：非法参数异常
SecurityException：安全型异常
NegativeArraySizeException：数组长度为负异常

八、异常使用原则
1、在当前方法声明中使用try-catch捕获异常
2、一个方法被覆盖时，覆盖他的方法必须抛出相同的异常或者异常的子类
3、如果父类抛出多个异常，则覆盖方法必须抛出那些异常的子集，不能抛出新的异常 。