异常概述与异常体系结构

  1. 概念:在Java语言中,将程序执行中发生的不正常情况称为“异常”(开发过程中的语法错误和逻辑错误不是异常)。

  2. Java程序在执行过程中所发生的的异常事件可分为两类:

    Error:Java虚拟机无法解决的严重问题。如JVM系统内部错误、资源耗尽等严重情况。比如:StackOverflowError(栈溢出)和OOM(java.lang.OutOfMeoryError,堆溢出)。一般不编写针对性的代码进行处理。

    Exception:其他因编程错误或偶然的外在因素导致的一般性问题,可以使用针对性的代码进行处理。例如:

    • 指针访问
    • 试图读取不存在的文件
    • 网络连接中断
    • 数组角标越界
  3. 对于这些错误,一般有两种解决方法:一是遇到错误就终止程序的运行。另一种方法时由程序员在编写程序时,就考虑到错误的检测、错误消息提示,以及错误的处理。

  4. 捕获错误最理想的是在编译期间,但有的错误只有在运行时才会发生。比如:除数为0,数组下标越界

    分类:编译时异常运行时异常

    红色:编译时异常,即受检(checked)异常。

    蓝色:运行时异常,即非受检(unchecked)异常。

  • 运行时异常

    • 是指编译器不要求强制处置的异常。一般是指编程时的逻辑错误,是程序员应该积极避免其出现的异常。java.lang.RuntimeException类及它的子类都是运行时异常。
    • 对于这类异常,可以不作处理,因为这类异常很普遍,若全处理会对程序的可读性和运行效率产生影响。
  • 编译时异常

    • 是指编译器要求必须处置的异常。即程序在运行时由于外界因素造成的一般性异常。编译器要求Java程序必须捕获或声明所有编译时异常。
    • 对于这类异常,如果程序不处理,可能会带来意想不到的结果。

常见异常

继承关系:

java.lang.Throwable

​ java.lang.Error:一般不编写针对性的代码进行处理

​ java.lang.Exception:可以进行一场处理

​ 编译时异常(checked)

​ IOException

​ FileNotFoundException

​ ClassNotFoundException

​ 运行时异常(unchecked,RuntimeException)

​ NullPointerException(空指针异常)

​ ArrayIndexOutOfBoundsException(数组下标越界)

​ ClassCastException

​ NumberFormatException(数字格式化异常)

​ InputMismatchException(输入不匹配异常)

​ ArithmeticException(算数异常)

面试题:常见的异常有哪些?举例说明

① 编译时异常:

​ IOException

​ FileNotFoundException

​ ClassNotFoundException

② 运行时异常:

​ NullPointerException(空指针异常)

​ ArrayIndexOutOfBoundsException(数组下标越界)

​ ClassCastException

​ NumberFormatException(数字格式化异常)

​ InputMismatchException(输入不匹配异常)

​ ArithmeticException(算数异常)

package top.triabin._02commonexception;

import java.io.File;
import java.io.FileInputStream;
import java.util.Date;
import java.util.Scanner;

import org.junit.jupiter.api.Test;

@SuppressWarnings("unused")
public class Exception {
//************************编译时异常************************
@Test
public void test7() {
// File file = new File("hello.txt");
// FileInputStream fis = new FileInputStream(file);//FileNotFoundException
// int data = fis.read();//IOException
// while(data !=-1) {
// System.out.println((char)data);
// data = fis.read();//IOException
// }
// fis.close();//IOException
}

//************************运行时异常************************
//ArithmeticException:算术异常
@Test
public void test6() {
int a = 10;
int b = 0;
System.out.println(a / b);
}

//InputMismatchException
@Test
public void test5() {
Scanner scan = new Scanner(System.in);
int score = scan.nextInt();//当输入类型不是int型时报错:InputMismatchException
System.out.println(score);
scan.close();
}

//NumberFormatException
@Test
public void test4() {
String str = "123";
str = "abc";
int num = Integer.parseInt(str);
System.out.println(num);
}

//ClassCastException
@Test
public void test3() {
Object obj = new Date();
String str = (String)obj;
}

//IndexOutOfBoundsException
@Test
public void test2() {
//ArrayIndexOutOfBoundsException
// int[] arr = new int[10];
// System.out.println(arr[10]);

//StringIndexOutOfBoundsException
String str = "abc";
System.out.println(str.charAt(3));
}

//NullPointerException
@SuppressWarnings("null")
@Test
public void test1() {
// int[][] arr = null;
// System.out.println(arr[3]);
String str = "abcd";
str = null;
System.out.println(str.charAt(0));
}
}

异常处理机制一:try-catch-finally

异常处理:抓抛模型

  1. 过程一:“抛”,程序正常执行中,一旦出现异常,就会在异常代码处生成一个对应异常类的对象。并将此对象抛出。

    一旦抛出对象以后,其后的代码就不再执行。

  2. 过程二:“抓”,可以理解为异常的处理方式:① try-catch-finally ②throws

try-catch-finally的使用

try{
//可能出现异常的代码
}catch(异常类型1 变量名1){
//处理异常的方式1
}catch(异常类型2 变量名2){
//处理异常的方式2
}
//……
finally{
//一定会执行的代码
}

说明

  1. finally是可选的

  2. 使用try将可能出现异常的代码包装起来,在执行过程中,一旦出现异常,就会生成一个对应异常类的对象,根据此对象的类型,去catch中进行匹配。

  3. 一旦try中的异常对象匹配到某一个catch时,就进入到catch中进行异常处理。一旦处理完成,就跳出当前try-catch结构(没有写finally的情况),继续执行其后的代码。

  4. catch中的异常类型如果没有子父类关系,则声明的先后(上下)无所谓;catch中的异常类型如果满足子父类关系,则要求一定先声明子类。否则,报错

  5. 常用的异常对象处理方式:

    ① String getMessage() 获取异常信息,返回字符串

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

  6. 在try结构中声明的变量,在try结构外无法调用。

    ​ 如果确实要在外面调用,可以先在try结构上面初始化变量,再在try结构后面调用。

  7. try-catch-finally结构可以嵌套。

体会1:使用try-catch-finally处理编译时异常,使得程序在编译时不再报错,但是运行时仍可能报错。相当于我们使用try-catch-finally将一个编译时可能出现的异常延迟到运行时出现。

体会2:开发中,由于运行时异常比较常见,所以我们通常就不针对运行时异常编写try-catch-finally了。针对于编译时异常,一定要考虑异常的处理。

package top.triabin._03trycatchfinally;

import org.junit.Test;

public class ExceptionTest1 {
@Test
public void test1() {
String str = "123";
str = "abc";
int num = 0;
try {
num = Integer.parseInt(str);
System.out.println("Hello--1");//未能执行此语句,因为程序遇到异常后直接抛出异常,停止执行后面的语句,转而执行catch操作,异常被catch解决后程序正常执行,所以后面的hello--2正常显示
}catch(NumberFormatException e) {
// System.out.println("出现数值转换异常了,莫慌……");

//String getMessage():
// System.out.println(e.getMessage());

//printStackTrace():
e.printStackTrace();
}
System.out.println(num);

System.out.println("Hello--2");
}
}

try-catch-finally中finally的使用

  1. finally是可选的。
  2. finally中声明的是一定会被执行的代码。即使catch中又出现异常了,try中有return语句,catch中有return语句等情况。
  3. 像数据库连接、输入输出流、网络编程Socket等资源,JVM是不能自动回收的,我们需要自己手动地进行手动地进行资源的释放。此时的资源释放,就需要声明在finally中。
package top.triabin._03trycatchfinally;

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

import org.junit.Test;

public class FinallyTest {
@Test
public void test2() {
FileInputStream fis = null;
try {
File file = new File("hello1.txt");
fis = new FileInputStream(file);//FileNotFoundException
int data = fis.read();//IOException
while(data != -1) {
System.out.print((char)data);
data = fis.read();//IOException
}
// fis.close();//IOException,将此结构放到finally结构中
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
if(fis != null)
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

@Test
public void testMethod() {
int num = method();
System.out.println(num);//先执行finally中的内容,再执行catch中的内容
}
public int method() {
try {
int[] arr = new int[10];
System.out.println(arr[10]);
return 1;
}catch(ArrayIndexOutOfBoundsException e) {
e.printStackTrace();
return 2;
}finally {
System.out.println("我一定会被执行");
}
}

@Test
public void test1() {
try {
int a = 10;
int b = 0;
System.out.println(a / b);
}catch(ArithmeticException e) {
e.printStackTrace();
}catch(Exception e) {
e.printStackTrace();
}finally {
System.out.println("楼主是真的帅!!!");
}
}
}

异常处理机制二:throws

throws + 异常类型

  1. “throws + 异常类型” 写在方法的声明处。指明方法执行时可能会抛出的异常类型。

    一旦方法执行时出现异常,仍会在异常代码处生成一个异常类的对象,此对象满足throws后异常类型时就会被抛出。异常代码后续代码就不再执行。

  2. 注意:try-catch-finally:真正将异常处理掉了。

    throws的方式只是将异常抛给了方法的调用者,并没有真正将异常处理掉。

  3. 开发中,如何选择使用try-catch-finally还是throws?

    • 如果父类中被重写的方法没有throws方式处理异常,则子类重写的方法也不能使用throws,意味着如果子类重写的方法中有异常,必须使用try-catch-finally方式处理。
    • 执行的方法a中,先后有调用了另外的几个方法,这几个方法时递进关系执行的。则这几个方法使用throws的方式进行处理。而执行的方法a可以考虑使用try-catch-finally方式进行处理。
    package top.triabin._04throws;

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

    /*
    * 异常处理的方式二:throws + 异常类型
    */
    public class ThrowsTest {
    public static void main(String[] args) {
    try{
    method2();
    }catch(IOException e) {
    e.printStackTrace();
    }

    method3();
    }

    public static void method3() {
    try {
    method2();
    } catch (IOException e) {
    e.printStackTrace();
    }
    }

    public static void method2() throws IOException{
    method1();
    }

    public static void method1() throws FileNotFoundException,IOException{
    File file = new File("hello.txt");
    FileInputStream fis = new FileInputStream(file);

    int data = fis.read();
    while(data != -1) {
    System.out.print((char)data);
    data = fis.read();
    }
    fis.close();
    }
    }
  4. 方法重写的规则之一:子类重写方法抛出的异常类型不大于父类被重写的方法抛出的异常类型。

    package top.triabin._04throws;

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

    /*
    * 方法重写的规则之一:
    * 子类重写方法抛出的异常类型不大于父类被重写的方法抛出的异常类型。
    *
    */
    public class OverrideTest {
    public static void main(String[] args) {
    OverrideTest test = new OverrideTest();
    test.display(new SubClass());
    }

    public void display(SuperClass s) {
    try {
    s.method();
    } catch (IOException e) {
    e.printStackTrace();
    }
    }
    }

    class SuperClass{
    public void method() throws IOException{

    }
    }

    class SubClass extends SuperClass{
    public void method() throws FileNotFoundException{

    }
    }

手动抛出异常:throw

关于异常对象的产生

  1. 系统自动生成的异常对象

  2. 手动生成一个异常对象,并抛出(throw)

    package top.triabin._05throw;

    public class StudentTest {
    public static void main(String[] args) {
    try {
    Student s = new Student();
    s.regist(-1001);
    System.out.println(s);
    } catch (Exception e) {
    // e.printStackTrace();
    System.out.println(e.getMessage());
    }
    }
    }

    class Student{
    private int id;

    public void regist(int id) throws Exception {
    if(id > 0) {
    this.id = id;
    }else {
    // System.out.println("您输入的数据非法!");
    //手动抛出一个异常对象
    // throw new RuntimeException("您输入的数据非法!");
    throw new Exception("您输入的数据非法!");
    }
    }

    @Override
    public String toString() {
    return "Student [id=" + id + "]";
    }
    }
    • 运行结果

用户自定义异常类

package top.triabin._06userdefined;
/*
* 如何自定义异常类?
* 1. 继承现有的异常结构:RuntimeException、Exception
* 2. 提供全局常量:serialVersionUID
* 3. 提供重载构造器
*
*/
public class MyException extends RuntimeException{
static final long serialVersionUID = -7034897193246939L;

public MyException() {

}
public MyException(String msg) {
super(msg);
}
}

练习1

  • 编写应用程序EcmDef.java,接收命令行的两个参数,要求不能输入负数,计算两数相除。

    对数据类型不一致(NumberFormatException)、缺少命令行参数(ArrayIndexOutOfBoundsException)、除以0(ArithmeticException)及输入负数(EcDef自定义的异常)进行处理。

  • 提示:

    (1) 在主类(EcmDef)中定义异常方法(ecm)完成两数相除功能。

    (2) 在main()方法中使用异常处理语句进行异常处理。

    (3) 在程序中,自定义对应输入负数的异常类(EcDef)。

    (4) 运行时接受参数 java EcmDef 20 10 //args[0]=“20” args[1]=“10”

    (5) Interger类的static方法parseInt(String s)将s转换成对应的int值。

    ​ 如:int a=Interger.parseInt(“314”); //a = 314

    * package top.triabin._06userdefined.exercise1;
    /**
    * 在程序中,自定义对应输入负数的异常类(EcDef)。
    */
    public class EcDef extends Exception{
    static final long serialVersionUID = -33875164229948L;

    public EcDef() {}
    public EcDef(String msg) {
    super(msg);
    }
    }
    package top.triabin._06userdefined.exercise1;

    public class EcmDef {
    public static void main(String[] args) {
    try {
    int i = Integer.parseInt(args[0]);
    int j = Integer.parseInt(args[1]);
    double result = ecm(i,j);
    System.out.println(result);
    } catch (NumberFormatException e) {
    System.out.println("数据类型不一致");
    } catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("缺少命令行参数");
    } catch (ArithmeticException e) {
    System.out.println("除数为0");
    } catch (EcDef e) {
    System.out.println(e.getMessage());
    }
    }
    /**
    * @Description
    * @author Dawn Lee
    * @version 1.0
    * @data 2020-10-1414:28:48
    *
    * @param i 被除数
    * @param j 除数
    * @return
    * @throws EcDef
    */
    public static double ecm(int i,int j) throws EcDef{
    if(i < 0 || j < 0) {
    throw new EcDef("分子或分母为负数了!");
    }
    return i / j;
    }
    }

    ① 数据类型不一致

    输入:12 abc

    ② 缺少命令行参数

    输入:12

    ③ 除数为0(自定义错误类型)

    输入:12 0

一首小悟结束异常处理

世界上最遥远的距离,是我在if里你在else里,似乎一直相伴又永远分离;

世界上最痴心的等待,是我当case你是switch,或许永远都选不上自己;

世界上最真情的相依,是你在try我在catch。无论你发神马脾气,我都默默承受,静静处理。到那时,再来期待我们的finally。


面试题

final、finally、finalize三者的区别?

类似:

throw和throws

​ throw:表示抛出一个异常类的对象,生成异常对象的过程。生命在方法体内。

​ throws:属于异常处理的一种方式,声明在方法的声明处。

Collection和Collections

String、StringBuffer和StringBuilder

ArrayList、LingkedList

HashMap、LinkedHashMap

重写、重载

结构不相似的:

抽象类、接口

==、equals

sleep()、wait()