JavaSE——认识异常

1.概念

  在生活中，人有时会生病，在程序中也是一样，程序猿是一帮办事严谨、追求完美的高科技人才。在日常开发中，绞尽脑汁将代码写的尽善尽美，在程序运行过程中，难免会出现一些奇奇怪怪的问题。有时通过代码很难去控制，比如：数据格式不对、网络不通畅、内存报警等。
   在Java中，将程序执行过程中发生的不正常行为称为异常。例如：
1.算术异常

2.数组越界异常

3.空指针异常

2. 异常体系结构

异常种类繁多，为了对不同异常或者错误进行很好的分类管理，Java内部维护了一个异常的体系结构：

3. 分类

  boolean ret = false;
        ret = func1();
        if(!ret){
            System.out.println("func1方法出错！");
        }
        ret = func2();
        if(!ret){
            System.out.println("func2方法出错！");
        }
        ret = func3();
        if(!ret){
            System.out.println("func3方法出错！");
        }
        ret = func4();
        if(!ret){
            System.out.println("func4方法出错！");
        }

 try{
            func1();

        }catch (Exception e){
            System.out.println("func1方法异常");
        }

 代码示例：

  public static int getElement(int[] array, int index) {
        if (null == array) {
            throw new NullPointerException("传递的数组为null");
        }
        if(index < 0 || index >= array.length){
            throw new ArrayIndexOutOfBoundsException("传递的数组下标越界");
        }
        return array[index];
    }
    public static void main(String[] args) {
        int[] array = {1,2,3};
        getElement(array, 3);
    }

运行结果如下：

4.3 异常的捕获

4.3.1 异常声明throws

代码示例：

 public static void func(int[] a) throws Exception {
        if(a==null){
            throw new Exception("传个参数看看....."+a);
        }
    }
    public static void main(String[] args) throws Exception {
        int[] a = null;
       func(a);
    }

 运行结果如下：

4.3.2 try-catch捕获并处理

throws 对异常并没有真正处理，而是将异常报告给抛出异常方法的调用者，由调用者处理。如果真正要对异常进行处理，就需要try-catch 。

语法格式：

try {

// 将可能出现异常的代码放在这里

} catch ( 要捕获的异常类型 e ){

// 如果 try 中的代码抛出异常了，此处 catch 捕获时异常类型与 try 中抛出的异常类型一致时，或者是 try 中抛出异常的基类

时，就会被捕获到

// 对异常就可以正常处理，处理完成后，跳出 try-catch 结构，继续执行后序代码

}[ catch ( 异常类型 e ){

// 对异常进行处理

} finally {

// 此处代码一定会被执行到

}]

// 后序代码

// 当异常被捕获到时，异常就被处理了，这里的后序代码一定会执行

// 如果捕获了，由于捕获时类型不对，那就没有捕获到，这里的代码就不会被执行

注意：

1. [] 中表示可选项，可以添加，也可以不用添加

2. try 中的代码可能会抛出异常，也可能不会

代码示例：

public static void func(int[] a) throws Exception {
        if(a==null){
            throw new Exception("传个参数看看....."+a);
        }
    }
    public static void main(String[] args) throws Exception {
        int[] a = null;
        try {
            func(a);
        }catch (Exception e){
            System.out.println("捕获到了Exception异常" + "异常正在处理...");
        }
        System.out.println("异常处理完成，程序继续执行...");
    }

运行结果如下：

注意事项：

1. try 块内抛出异常位置之后的代码将不会被执行

2. 如果抛出异常类型与 catch 时异常类型不匹配，即异常不会被成功捕获，也就不会被处理，继续往外抛，直到JVM收到后中断程序 ---- 异常是按照类型来捕获的

3. try 中可能会抛出多个不同的异常对象，则必须用多个 catch 来捕获 ---- 即多种异常，多次捕获

如果多个异常的处理方式是完全相同 , 也可以写成这样：

catch (ArrayIndexOutOfBoundsException | NullPointerException e) {
...
}

如果异常之间具有父子关系，一定是子类异常在前 catch ，父类异常在后 catch ，否则语法错误

4. 可以通过一个 catch 捕获所有的异常，即多个异常，一次捕获 ( 不推荐 )

注意： 由于 Exception 类是所有异常类的父类 . 因此可以用这个类型表示捕捉所有异常 .

拓展：

关于异常的处理方式

异常的种类有很多 , 我们要根据不同的业务场景来决定 .

对于比较严重的问题 ( 例如和算钱相关的场景 ), 应该让程序直接崩溃 , 防止造成更严重的后果

对于不太严重的问题 ( 大多数场景 ), 可以记录错误日志 , 并通过监控报警程序及时通知程序猿

对于可能会恢复的问题 ( 和网络相关的场景 ), 可以尝试进行重试 .

在我们当前的代码中采取的是经过简化的第二种方式 . 我们记录的错误日志是出现异常的方法调用信息 , 能很快速的让我们找到出现异常的位置. 以后在实际工作中我们会采取更完备的方式来记录异常信息 .

4.3.3 finally 

代码示例：

public static void main(String[] args) {
try{
int[] arr = {1,2,3};
arr[100] = 10;
arr[0] = 10;
}catch (ArrayIndexOutOfBoundsException e){
System.out.println(e);
}finally {
System.out.println("finally中的代码一定会执行");
}
System.out.println("如果没有抛出异常，或者异常被处理了，try-catch后的代码也会执行");
}

 运行结果如下：

4.4 异常的处理流程

如果本方法中没有合适的处理异常的方式, 就会沿着调用栈向上传递,如果向上一直传递都没有合适的方法处理异常, 最终就会交给 JVM 处理, 程序就会异常终止(和我们最开始未使用 try-catch 时是一样的).

• 程序先执行 try 中的代码
• 如果 try 中的代码出现异常, 就会结束 try 中的代码, 看和 catch 中的异常类型是否匹配.
• 如果找到匹配的异常类型, 就会执行 catch 中的代码
• 如果没有找到匹配的异常类型, 就会将异常向上传递到上层调用者.
• 无论是否找到匹配的异常类型, finally 中的代码都会被执行到(在该方法结束之前执行).
• 如果上层调用者也没有处理的了异常, 就继续向上传递.
• 一直到 main 方法也没有合适的代码处理异常, 就会交给 JVM 来进行处理, 此时程序就会异常终止.

拓展：

关于 " 调用栈 "

方法之间是存在相互调用关系的 , 这种调用关系我们可以用 " 调用栈 " 来描述 . 在 JVM 中有一块内存空间称为"虚拟机栈 " 专门存储方法之间的调用关系 . 当代码中出现异常的时候 , 我们就可以使用 e.printStackTrace(); 的方式查看出现异常代码的调用栈

5. 自定义类

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

class LogIn {
    private static String userName = "admin";
    private static String password = "13456";
    public static void loginInfo(String Name, String code)
            throws UserNameException,PasswordException{
        if (!Name.equals(userName)) {
            throw new UserNameException("用户名错误！");
        }
        if (!password.equals(code)) {
            throw new PasswordException("用户名错误！");
        }
        System.out.println("登陆成功");
    }
    public static void main(String[] args) {
        try {
            loginInfo("admin", "12356");
        } catch (UserNameException e) {
            e.printStackTrace();
        } catch (PasswordException e) {
            e.printStackTrace();
        }
    }
}

 注意：

• 自定义异常通常会继承自 Exception 或者 RuntimeException
• 继承自 Exception 的异常默认是受查异常
• 继承自 RuntimeException 的异常默认是非受查异常

本文是作者学习后的总结，如果有什么不恰当的地方，欢迎大佬指正！！！