章八、异常 —— 概述、常见异常、异常处理、运行期异常和编译器异常

一、 Java 异常概述

---

        在使用计算机语言进行项目开发的过程中，即使程序员把代码写得尽善尽美，在系统的运行过程中仍然会遇到一些问题，因为很多问题不是靠代码能够避免的，比如：客户输入数据的格式，读取文件是否存在，网络是否始终保持通畅等等。

●  异常

        指的是程序在执行过程中，出现的非正常情况，如果不处理最终会导致 JVM 的非正常停止。异常指的并不是语法错误。语法错了，编译不通过，不会产生字节码文件，根本不能运行。

●  异常的抛出机制

Java中是如何表示不同的异常情况，又是如何让程序员得知，并处理异常的呢？

        Java中把不同的异常用不同的类表示，一旦发生某种异常，就创建该异常类型的对象，并且抛出。然后程序员可以捕获到这个异常对象，并处理；如果没有捕获这个异常对象，那么这个异常将会导致程序终止。

例如：

●  如何对待异常

对于程序出现的异常，一般有两种解决方法：

        一是遇到错误就终止程序的运行。

        另一种方法是程序员在编写程序时，就充分考虑到各种可能发生的异常和错误，极力预防和避免。实在无法避免的，要编写相应的代码进行异常的检测、以及异常的处理，保证代码的健壮性。

二、 java异常体系结构

---

Throwable可分为两类：Error和Exception。

分别对应着 java.lang.Error 和 java.lang.Exception 两个类

 

Error：Java 虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。一般不编写针对性的代码进行处理。

        包括：StackOverflowError（栈内存溢出）和OutOfMemoryError（堆内存溢出，简称OOM）。

Exception：其它因编程错误或偶然的外在因素导致的一般性问题，需要使用针对性的代码进行处理，使程序继续运行。否则一旦发生异常，程序也会挂掉。

三、 常见的异常

---

 ArithmeticException        算数异常

ArrayIndexOutOfBoundsException        数组越界

StringIndexOutOfBoundsException        字符串数组越界

ClassCastException        类转换异常

NumberFormatExcepction        数字初始化异常

NullPointExecption        使用null中的方法/属性，一般也叫空指针异常

●  Error

堆溢出: OutOfMemoryError

import java.util.ArrayList;
import java.util.Arrays;

public class Demo {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        while (true){
            arrayList.add(new Integer(1000));
        }
    }
}

 

栈溢出: StackOverflowError

●  Execption

数组越界异常

类型转换异常

数字格式化异常

空指针异常

算术异常

import java.util.Scanner;

public class JavaException {
    public static void main(String[] args) {
        /*
        异常：程序在运行过程中的不正常情况
        例如：用户输入数据有误、读写文件被强制删除、网络传输过程断网
        注   代码编写错误不是异常范围的问题

        java中默认的异常处理机制，将出现的异常，按照不同的类型分类，为每种异常封装了一个类来表示
        出现了某种类型的异常情况时，会抛出此类的对象，然后终止虚拟机的运行

         使用异常处理机制对程序运行过程中出现的异常情况进行捕捉并处理


         */
        /*
        int a = 10;
        int b = 0;
        System.out.println(a/b);
        System.out.println("aaaaaaaaa");
        */

        /* ArrayIndexOutOfBoundsException 数组索引越界
        int[] a = new int[2];
        System.out.println(a[3]);
         */

        /* StringIndexOutOfBoundsException 字符串索引越界
        String s = "abc";
        s.charAt(4);
         */


    }
}

四、 异常处理

---

Java编程语言使用异常处理机制为程序提供了错误处理的能力 

Java的异常处理是通过5个关键字来实现的：try、catch、finally、throw、throws

●  基本语法

try{

        可能会发生异常的代码

}catch(异常类型 引用名){

        异常处理代码

}finally{

        必须执行代码

}

public class ExceptionDemo {
    /*
    异常处理：
    在编码时，就针对可能出现的代码（经验问题）预先编写一些处理机制
    程序运行
    出现异常
    执行处理机制
    继续运行后续的程序

    try{
        编写可能出现异常的代码
        算数异常
    }
    catch(异常类型 数组越界异常){
        处理机制
    }

     */
    public static void main(String[] args) {
        int a = 10;
        int b = 0;

        try{
            int c = a/b; //算术运算可能会有问题
        }catch (ArithmeticException ai){
            ai.printStackTrace();//在开发期间，最好把问题信息打印出来，以供开发人员定位错误位置
            System.out.println("算数异常");
        }
        System.out.println("aaaaaaaa");
    }
}

●  try

检测不安全的代码块（发现异常）

        try 块 中任何一条语句发生了异常，下面的代码将不会被执行，程序将跳转到异常处理代码块中，即 catch 块 。因此，不要随意将不相关的代码放到try块中，因为随时可能会中断执行。

●  catch

把抓到的类型匹配的异常捕获，保证程序能继续运行下去

        catch语句必须紧跟着try语句之后，称为捕获异常，也就是异常处理函数，一个try后面可以写多个catch，分别捕获不同类型的异常，要从子类往父类的顺序写，否则有编译错误

捕获异常的有关信息：

        与其它对象一样，可以访问一个异常对象的成员变量或调用它的方法。

• getMessage() 获取异常信息，返回字符串

• printStackTrace() 获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。

public class ExceptionDemo1 {

    public static void main(String[] args) {

        try{
            int[] a = new int[5];
            for(int i = 0;i<=a.length;i++){
                System.out.println(a[i]);
            }

            int num = Integer.parseInt("12a");

            String s =null;
            s.length();

        }catch (ArrayIndexOutOfBoundsException aIndex){
            aIndex.printStackTrace();
            System.out.println("数组越界，越界索引为："+aIndex.getMessage());

        }catch (NumberFormatException nex){
            nex.printStackTrace();
            System.out.println("数字格式异常："+nex.getMessage());
        
        }catch (Exception e){//可以捕获任何异常类型，但必须放在最后面
            e.printStackTrace();
            System.out.println("系统忙");
        }
        System.out.println("aaaaaaaa");
    }
}

●  finally

finally该内容总是会执行的，只能有一个finally语句段

        必须执行的逻辑

}

场景1：

        异常未被捕获到，后面的代码无法执行，但是finally中的代码仍会执行：

public class ExceptionDemo2 {

    public static void main(String[] args) {

        try{
            int num = Integer.parseInt("10a");
        }catch (NumberFormatException nex){
            nex.printStackTrace();
            System.out.println(nex.getMessage());
        }finally {
            System.out.println("aaaaaaaaaa");
        }

        System.out.println("bbbbbbb");
        
        //若异常没有被捕获到，后续代码无法执行，但finally中的代码会执行
        try{
            int num = Integer.parseInt("10a");
        }catch (ArrayIndexOutOfBoundsException nex){
            nex.printStackTrace();
            System.out.println(nex.getMessage());
        }finally {
            System.out.println("aaaaaaaaaa");
        }
        System.out.println("bbbbbbb");
    }
}

场景2：

        确保在文件出现异常的情况下，仍然最终把流对象关闭掉 

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileExecptionDemo {
    public static void main(String[] args) throws IOException {
        FileInputStream in = null;
        try {
            in = new FileInputStream("D:/JAVA/file/demo.txt");
        }catch (FileNotFoundException fNot){
            fNot.printStackTrace();
        }
        //文件一旦找不到，就会出现异常
        //文件必须关闭，但如果不存在，关闭就不会执行，所以要放到finally中
        finally {
            if(in!=null) {
                in.close();
            }
        }


    }
}

场景3：

        无论是在 try 还是 catch 进行 return，finally 中的代码会在 return 之前执行 

public class ReturnDemo {
    public static void main(String[] args) {
        int a = 4;
        int b = 0;
        System.out.println(test(a,b));
    }
    static int test(int a,int b){
        int c;
        try{
            c = a/b;
            return c;
        }catch (ArithmeticException AE){
            AE.printStackTrace();
            System.out.println("算数异常");
            return -1;
        }finally {
            System.out.println("关闭流");//无论如何都会执行
        }

    }
}

●  throws

        定义一个方法的时候可以使用 throws关键字 声明，表示此方法不处理异常，而交给方法调用处进行处理。

例如:

public void test throws 异常1，异常2，异常3{

}

● 任何方法都可以使用 throws关键字 声明异常类型，包括抽象方法。

● 调用使用了 throws 的方法时必须处理声明的异常，要么使用 try-catch ，要么继续使用throws声明（最顶层方法必须处理异常，不能再throws）。

● 如果抛出的是运行期异常，则不会有任何提示，需要查看所调用的方法结构

import java.io.UnsupportedEncodingException;

public class ThrowsDemo {
    public static void main(String[] args){
        try {
            mainA();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        //最顶层的mian方法就不能再抛出了，必须对异常进行处理
    }
    static void mainA() throws UnsupportedEncodingException {
        mainB();
        //但mainA中就不会知道会出现异常
        //因而对于底层方法不建议处理异常
        /*
        因此
        throws 异常类型，声明此方法中可能会出现异常，但是该方法不处理异常
        谁调用谁处理
         */
    }
    static void mainB() throws UnsupportedEncodingException {
        String s = "abc";
        s.getBytes("gbk-1");//根据一个编码表进行转换
        // throws UnsupportedEncodingException 表示此方法可能会出现异常
        /*
       而我们使用可能存在问题的方法时 也因此需要处理问题
       1是将方法用try{}catch(){}包裹
       2是和原方法一样直接throws
         */
        System.out.println();
    }
}

五、 运行期异常和编译期异常

---

异常分为运行期异常和编译期异常两种

● 编译时期异常（即checked异常、受检异常）：

        在代码编译阶段，编译器就能明确警示当前代码可能发生（不是一定发生）XX异常，并明确督促程序员提前编写处理它的代码。如果程序员没有编写对应的异常处理代码，则编译器就会直接判定编译失败，从而不能生成字节码文件。通常，这类异常的发生不是由程序员的代码引起的,例如：FileNotFoundException（文件找不到异常）。

● 运行时期异常（即runtime异常、unchecked异常、非受检异常）：

        在代码编译阶段，编译器完全不做任何检查，无论该异常是否会发生，编译器都不给出任何提示。只有等代码运行起来并确实发生了XX异常，它才能被发现。通常，这类异常是由程序员的代码编写不当引起的，只要稍加判断，或者细心检查就可以避免。

java.lang.RuntimeException类 及它的子类都是运行时异常。比如：

ArrayIndexOutOfBoundsException        数组下标越界异常

ClassCastException        类型转换异常

六、 自定义异常

---

throw关键字用于显式抛出异常,抛出的时候是抛出的是一个异常类的实例化对象。

自定义异常就是自己定义的异常类，也就是API中的标准异常类的直接或间接的子类

● 作用：用自定义异常标记业务逻辑的异常，避免与标准异常混淆

● 自定义异常类

● 基本语法

public class 异常类名 extends Exception/RuntimeException{

        public 异常类名(String msg){

                super(msg);

        }

}

自定义异常类中往往不写其他方法，只重载需要使用的构造方法

● 继承Exception,在方法中使用throw抛出后,必须在方法中 try-catch 或 throws 抛出

●  示例​​​​​​

public class MyThrow {
    public static void main(String[] args) {
        
        try {
            char c = level(101);
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println(e.getMessage());//打印自定义的异常问题
        }

        try {
            int c = level('C');
        } catch (MyThrow2 myThrow2) {
            myThrow2.printStackTrace();
            System.out.println(myThrow2.getMessage());
        }

        System.out.println("aaaaaaa");
    }
    public static char level(int score) throws Exception {
        if(score<0||score>100){
            throw new Exception("非法的分数");
            //没有这种异常，那就需要自定义
        }
        if(score>=60){
            return 'A';
        }else {
            return 'B';
        }
    }
    public static int level(char score) throws MyThrow2 {
        if(score>'B'||score<'A'){
            throw new MyThrow2("非法分数");
        }
        return 100;
    }
}

/**
 分数自定义异常
 当分数不合法时抛出此类异常的对象
 */
public class MyThrow2 extends Exception{
    public MyThrow2(String Error){
        super(Error);
    }
    public MyThrow2(){

    }
}

七、 throws 和 throw 的区别

---

throws：

        用在方法声明时，表示此方法中可能会出现某种类型的异常，此方法不处理异常，而是交给调用该方法的来处理

throw：

        用在方法体中，当不满足某种条件时，主动抛出一个具体的异常对象，该方法终止运行，并继续往下执行