一篇文章带你理解并掌握Java的异常

文章目录

  • 前言
  • 一、异常处理
  • 二、异常类型
  • 三、异常处理的其它方面
    • 1.声明异常
    • 2.抛出异常
    • 3.捕获异常
    • 4.示例学习:声明、抛出和捕获异常
  • 四、finally子句
  • 五、何时使用异常
  • 六、重新抛出异常
  • 七、链式异常
  • 八、创建自定义异常类


前言

异常是运行时错误,异常处理使得程序可以处理运行时错误,并且继续通常的执行。异常机制提供了程序退出时的安全通道。当出现错误后,程序执行流程发生改变,程序的控制权转移到异常处理器。

编译错误:程序没有遵循语法规则,编译程序能够自己发现并提示我们错误的原因和位置。

运行时错误:程序在执行时,运行环境发现了不能执行的操作。

逻辑错误:程序没有按照预期的逻辑顺序执行。

在程序运行过程中,如果JVM检测出一个不可能执行的操作,就会出现运行时错误。例如,如果使用一个越界的下标访问数组,程序就会产生一个ArrayIndexOutOfBoundsException的运行时错误;如果程序需要输入一个整数的时候用户输入了一个double值,会得到InputMismatchException的运行时错误。

在Java中,运行时错误会被作为异常抛出。异常就是一种对象,表示阻止正常运行的错误或者情况。如果异常没有处理,那么程序将会非正常终止。


一、异常处理

异常是从方法抛出的,方法的调用者可以捕获并处理该异常。

为了演示异常处理,包括异常是如何创建以及抛出的,我们从读取两个整数并显示它们商的例子开始。

import java.util.Scanner;

/**
 * @author MNH
 * @version 1.0
 * @project Name: JAVA基础
 * @file Name: Quotient
 * @desc 功能描述
 * @by IDE: IntelliJ IDEA
 */
public class Quotient {
     
    public static void main(String[] args) {
     
        Scanner input=new Scanner(System.in);
        System.out.println("Enter two integer:");
        int num1=input.nextInt();
        int num2=input.nextInt();
        System.out.println(num1+"/"+num2+"="+(num1/num2));
    }
}

一篇文章带你理解并掌握Java的异常_第1张图片
如果输入0赋值给第二个数字,那就会产生一个运行时错误,因为不能用一个整数除以0(注意,一个浮点数除以0是不会产生异常的)。解决这个错误的一个简单方法就是添加一个if语句来测试第二个数字。

import java.util.Scanner;

/**
 * @author MNH
 * @version 1.0
 * @project Name: JAVA基础
 * @file Name: QuotientWithIf
 * @desc 功能描述
 * @by IDE: IntelliJ IDEA
 */
public class QuotientWithIf {
     
    public static void main(String[] args) {
     
        Scanner input=new Scanner(System.in);
        System.out.println("请输入两个整数:");

        int num1=input.nextInt();
        int num2=input.nextInt();

        if(num2!=0){
     
            System.out.println(num1+"+"+num2+"="+(num1/num2));
        }else{
     
            System.out.println("被除数不能为0");
        }
    }
}

为了介绍异常处理,我们使用一个方法计算商,程序如下:

import java.util.Scanner;

/**
 * @author MNH
 * @version 1.0
 * @project Name: JAVA基础
 * @file Name: QuotientWithMethod
 * @desc 功能描述
 * @by IDE: IntelliJ IDEA
 */
public class QuotientWithMethod {
     
    public static int quotient(int num1,int num2){
     
        if(num2==0){
     
            System.out.println("被除数不能为0");
            System.exit(1);
        }
        return num1/num2;
    }

    public static void main(String[] args) {
     
        Scanner input=new Scanner(System.in);

        System.out.println("请输入两个整数:");

        int num1=input.nextInt();
        int num2=input.nextInt();

        System.out.println(num1+"/"+num2+"="+quotient(num1,num2));
    }
}

在这里插入图片描述
在这里插入图片描述
方法quotient返回两个整数的商,如果num2为0,则不能返回一个值,程序在System.exit(1)处终止,这显然是一个问题。不应该让方法来终止程序—应该由调用者决定是否终止程序。

方法如何通知它的调用者一个异常产生了呢?Java可以让一个方法抛出一个异常,该异常可以被调用者捕获和处理。

import java.util.Scanner;

/**
 * @author MNH
 * @version 1.0
 * @project Name: JAVA基础
 * @file Name: QuotientWithException
 * @desc 功能描述
 * @by IDE: IntelliJ IDEA
 */
public class QuotientWithException {
     
    public static void quotient(int num1, int num2) {
     
        try {
     
            if (num2 == 0) {
     
                throw new ArithmeticException("被除数不能等于0");//抛出一个异常
            }
            System.out.println(num1 + "/" + num2 + "=" +(num1/num2));
        }catch (ArithmeticException e) {
     
            System.out.println("被除数不能为0");
        }
        System.out.println("程序继续......");
    }

    public static void main(String[] args) {
     
        Scanner input = new Scanner(System.in);
        System.out.println("请输入两个整数:");

        int num1 = input.nextInt();
        int num2 = input.nextInt();

        quotient(num1,num2);
    }
}

//异常就是从一个异常类创建的对象

//本程序中异常就是Java.lang.ArithmeticException的构造方法ArithmeticException(str)被调用以创建异常类对象,str是描述异常的消息

一篇文章带你理解并掌握Java的异常_第2张图片
如果num2等于0,,方法通过执行以下语句抛出一个异常:throw new ArithmeticException(“被除数不能为0”)。在这种情况下,抛出的值为new ArithmeticException(“被除数不能为0”),称为一个异常。throw语句的执行称为抛出一个异常。异常就是从异常类创建的对象。在这种情况下,异常类就是java.lang.ArithmeticException。构造方法ArithmeticException(str)被调用以构建一个异常对象,其中str是描述异常的消息。

当异常被抛出时,正常的执行流程被中断。就像他的名字所提示的,“抛出异常”就是将异常从一个地方传递到另一个地方。调用方法的语句也包含在一个try块和一个catch块中。try块包含了正常情况下执行的代码,异常被catch块所捕获。catch块中的代码被执行以处理异常,之后,catch块之后的语句被执行。

throw语句类似方法的调用,但不同于调用方法的是,它调用的是catch块。从某种意义上讲,catch块就像带参数的方法定义,这些参数匹配抛出的值的类型。但是它不像方法,在执行完catch块之后,程序控制不返回到throw语句,而是执行catch块后的下一条语句。

catch(ArithmeticException ex)中的标识符ex的作用很像是方法中的参数,这个参数称为catch块中的参数。ex之前的类型(如,ArithmeticException)指定了catch块可以捕获的异常类型。一旦捕获该类型,就能从catch块体中的参数访问这个抛出的值。

一个异常可能是通过try块中的throw语句直接抛出,或者调用一个可能会抛出异常的方法而抛出。

异常处理的优点:它能使方法抛出一个异常给它的调用者,并由调用者处理该异常。如果没有这个能力,那么被调用的方法就必须自己处理异常或者终止该程序。被调用的方法通常不知道在出现错误时应该做些什么,只有调用者自己清楚出现错误时需要做些什么。异常处理最根本的优势就是将检测错误(由被调用的方法完成)从处理错误中分离出来。

import java.util.Scanner;

/**
 * @author MNH
 * @version 1.0
 * @project Name: JAVA基础
 * @file Name: InputMismatchException
 * @desc 功能描述
 * @by IDE: IntelliJ IDEA
 */
public class InputMismatchException {
     
    public static void main(String[] args) {
     
        Scanner input=new Scanner(System.in);
        boolean continueInput=true;

        while(continueInput){
     
            try{
     
                System.out.println("请输入一个整数:");
                input.nextInt();
                continueInput=false;
            }catch(java.util.InputMismatchException e){
     
                System.out.println("输入的不是整数,请重新输入");
                input.nextLine();
            }
        }
    }
}

//变量continueInput控制循环,它的初始值是true,当键入一个整数时,该值就变成false

一篇文章带你理解并掌握Java的异常_第3张图片
当执行input.nextInt()时,如果输入的不是一个整数,就会产生一个InputMismatchException异常。

二、异常类型

异常是对象,对象都采用类来定义。异常的根类是java.lang.Throwable。Throwable类是所有异常类的根,所有Java异常类都直接或间接地继承自Throwable,可以通过继承Exception或者Exception的子类来创建自己的异常类。

这些异常类可以分为三种主要类型:系统错误、异常或运行时异常。(1)系统错误:系统错误是由Java虚拟机抛出的,用Error类表示的。Error类描述的是内部系统错误,这样的错误很少发生。如果发生,除了通知用户以及尽量稳妥地终止程序外,几乎什么也做不了。(2)异常:异常是用Exception类表示的,它描述的是由你的程序和外部环境引起的错误,这些错误能被程序捕获和处理。(3)运行时异常:运行时异常是用RuntimeException类表示的,它描述的是程序设计错误,例如,错误的类型转换、访问一个越界数组或数值错误,运行时异常通常表明了编程错误。

RuntimeException、Error以及它们的子类都称为免检异常,在大多数情况下,免检异常都会反映出程序设计上不可恢复的逻辑错误。例如,如果通过一个引用变量访问一个对象之前并未将一个对象赋值给它,就会抛出NullPointerException异常;如果访问一个数组的越界元素,就会抛出IndexOutOfBoundsException异常。这些都是程序中必须纠正的逻辑错误。免检异常可能在程序的任何一个地方出现,为避免过多地使用try-catch块,Java语言不强制要求编写代码捕获或声明免检异常。所有其它异常称为必检异常,意味着编译器会强制程序员检查并通过try-catch块处理它们,或者在方法头中声明。

必检异常增加了代码的健壮性,但是为了对异常进行抛出、捕获和处理,需要增加较多代码,会降低代码的可读性。如果异常影响到系运行的安全性和正确性的时候,必须对必检异常进行处理,否则这些必检异常是可以转换成免检异常。

三、异常处理的其它方面

Java的异常处理模型基于三种基本操作:声明一个异常、抛出一个异常、捕获一个异常。

1.声明异常

Java解释器调用main方法开始执行一个程序,当前执行的语句必属于某个方法,每个方法都必须声明它可能抛出的必检异常的类型,称为声明异常。因为任何代码都可能发生系统错误和运行时错误,因此Java不要求在方法中显示地声明Error和RuntimeException。然而,方法要跑出的其它异常都必须在方法头中显示声明,这样,方法的调用者会被告知有异常。

为了在方法中声明一个异常,就要在方法头中使用关键字throws,如:public void method() throws IOException,关键字throws表明method()方法可能会抛出异常IOException。如果方法可能抛出多个异常,就可以在关键字throws后添加一个用逗号分隔的异常列表:public void method() throws Exception1,Exception2,…,ExceptionN。如果父类中的方法没有声明异常,那么就不能在子类中对其重写时声明异常。

2.抛出异常

检测到错误的程序可以创建一个合适的异常类型的实例并抛出它,这称为抛出一个异常,如throw new IllegalArgumentException(“Wrong argument”)。IllegalArgumentException是Java API中的一个异常类,通常,Java API中每个异常类都至少有两个构造方法:一个无参构造方法和一个带有可以描述这个异常的String参数的构造方法,该参数称为异常消息,它可以通过一个异常对象调用getMessage()获取。

声明异常的关键字是throws,抛出异常的关键字是throw。

3.捕获异常

当抛出一个异常时,可以在try-catch块中捕获和处理它。

try{
     

}catch(Exception1 ex1){
     

}catch(Exception2 ex2){
     

}
...
catch(ExceptionN exN){
     

}

如果在执行try块的过程中没有出现异常,则跳过catch子句。如果try块中的某条语句抛出一个异常,Java就会跳过try块中剩余的语句,然后开始查找处理这个异常的代码,处理异常的这个代码称为异常处理器。从第一个到最后一个逐个检查catch块,判断在catch块中的异常类实例是否是该异常对象的类型。如果是,就将该异常对象赋值给所声明的变量,然后执行catch块中的代码。如果没有发现异常处理器,Java会退出这个方法,把异常传递给这个方法的调用者,继续同样的过程来查找处理器。如果在调用的方法链中找不到处理器,程序就会终止并且在控制台上打印出错误信息。查找处理器的过程称为捕获一个异常。

假设main方法调用method1()方法,method1()方法调用method2()方法,method2()方法调用method3()方法,method3()方法抛出一个异常,考虑下面的情形:

main method{
     
	try{
     
		method1();
		statement1
	}catch(Exception1 ex1){
     

	}
	statement2
}

class method1{
     
	try{
     
		method2();
		statement3
	}catch(Exception2 ex2){
     

	}
	statement4
}

class method2{
     
	try{
     
		method3();//一个异常在method3()方法中抛出
		statement5
	}catch(Exception3 ex3){
     

	}
	statement6
}

如果异常类型是Exception3,它就会被method2()中处理异常ex3的catch块捕获,跳过statement5,然后执行statement6。

如果异常类型是Exception2,,则退出method2()方法,控制被返回给method1()方法,而这个异常就会被method1()中处理异常ex2的catch块捕获,跳过statement3,然后执行statement4。

如果异常类型是Exception1,则退出method1()方法,控制被返回给main()方法,而这个异常就会被main()方法中处理异常ex1的catch块捕获,跳过statement1,然后执行statement2。

如果异常类型没有在method2、method1、main方法中捕获,程序就会终止,不执行statement1和statement2。

各种异常类都可以从一个共同的父类中派生。如果一个catch块可以捕获一个父类的异常对象,那么它就可以捕获那个父类的所有子类的异常对象。

在catch块中异常被指定的顺序是非常重要的,如果父类的catch块出现在子类的catch块之前,就会导致编译错误。

try{
     

}catch(Exception e){
     

}catch(RuntimeException ex){
     

}

//错误的顺序
try{
     

}catch(RuntimeException e){
     

}catch(Exception ex){
     

}

//正确的顺序

对于使用同样的代码处理多种异常的情况,可以使用JDK7的新的多捕获特征简化异常的代码书写。语法是:

catch(Exception1 | Exception2 | ... |ExceptionN e){
     

}

每个异常使用竖线(|)与下一个分隔,如果其中一个异常被捕获,则执行处理的代码。

4.示例学习:声明、抛出和捕获异常

创建一个CircleWithException类的对象,如果setRadius(double radius)中radius是负数,则抛出一个IllegalArgumentException异常。

/**
 * @author MNH
 * @version 1.0
 * @project Name: JAVA基础
 * @file Name: CircleWithException
 * @desc 功能描述
 * @by IDE: IntelliJ IDEA
 */
public class CircleWithException {
     
    private double radius;
    private static int numberOfCircle=0;

    public CircleWithException(double radius){
     
        setRadius(radius);
        numberOfCircle++;
    }

    public CircleWithException(){
     
        this(0);
    }

    public double getRadius(){
     
        return radius;
    }

    public void setRadius(double radius){
     
        if(radius>=0) {
     
            this.radius = radius;
        }else{
     
            throw new IllegalArgumentException("半径不能为负数");
        }
    }

    public double area(){
     
        return radius*radius*3.14;
    }

    public static int getNumberOfCircle(){
     
        return numberOfCircle;
    }

    public static void main(String[] args) {
     
        try{
     
            CircleWithException circleWithException1=new CircleWithException(2.0);
            CircleWithException circleWithException2=new CircleWithException(-2.0);
            CircleWithException circleWithException3=new CircleWithException();
        }catch(IllegalArgumentException e){
     
            System.out.println(e.toString());
        }

        System.out.println("共有"+numberOfCircle+"个圆被创建");
    }
}

在这里插入图片描述
IllegalArgumentException是异常类RuntimeException(免检异常)的子类,所以,如果不使用try语句,这个测试程序也能编译成功。

万一出现了异常,程序仍然会继续,而如果处理器没有捕获到这个异常,程序就会突然中断。

当没有异常发生时,try-catch的存在对系统性能的影响很小,可以说不会引起额外的系统开销。

异常发生后:(1)初始化异常对象(2)从调用栈返回(3)沿方法调用链来传播异常,以找到它的异常处理器。

四、finally子句

无论异常是否发生,finally子句总会被执行。

有时候,不论异常是否出现或是否被捕获,都希望执行某些代码。Java的finally子句可以用来实现这个目的,finally子句的语法如下:

try{
     
	statements;
}catch(Exception e){
     

}finally{
     
	finalStatements;
}

在任何情况下,finally块中的代码都会执行,不论try块中是否出现异常或者是否被捕获。考虑以下三种可能出现的情况:(1)如果try块中没有出现异常,执行fianlStatements,然后执行try语句的下一条语句;(2)如果try块中有一条语句引起了异常并被catch块捕获,会跳过try块的其它语句,执行catch块和finally子句,并执行try语句后的下一条语句;(3)如果try块中的一条语句引起异常,但是没有被任何catch块捕获,就会跳过try块中的其它语句,执行finally子句,并且将异常传递给这个方法的调用者。

即使在到达finally块之前有一个return语句,finally块还是会执行,同时使用finally子句时可以省略catch块。

五、何时使用异常

当错误需要被方法的调用者处理的时候,方法应该抛出一个异常。

try块包含正常情况下执行的代码,catch块包含异常情况下执行的代码。异常处理将错误处理代码从正常的编程中分离出来,这样,就可以使程序更易读、更易修改。由于异常处理需要初始化新的异常对象,需要从调用栈返回,而且还需要沿着方法调用链来传播异常以便找到它的异常处理器,所以异常处理需要更多的时间和资源。

异常发生在方法中,如果想让该方法的调用者处理异常,应该创建一个异常对象并将其抛出。如果能在发生异常的方法中处理异常,那么就不需要抛出或使用异常。一般来说,一个项目中多个类都会发生的共同异常应该考虑设计为一个异常类。对于发生在个别方法中的简单错误最好进行局部处理,无需抛出异常,这可以通过使用if语句来检测错误并实现。

六、重新抛出异常

如果异常处理器不能处理一个异常,或者只是简单地希望他的调用者注意到该异常,Java允许该异常处理器重新抛出异常。

try{
     
	statements;
}catch(Exception ex){
     
	throw ex;
}

语句throw ex重新抛出异常给调用者,以便调用者的其它处理器获得处理异常ex的机会。

七、链式异常

与另一个异常一起抛出一个异常,构成了链式异常。

有时候,可能需要同最初异常一起抛出一个新异常(带有附加信息),称为链式异常。

/**
 * @author MNH
 * @version 1.0
 * @project Name: JAVA基础
 * @file Name: ChainedExceptionDemo
 * @desc 功能描述
 * @by IDE: IntelliJ IDEA
 */
public class ChainedExceptionDemo {
     
    public static void method3() throws Exception{
     
        throw new Exception("异常来自method3()方法");
    }

    public static void method2() throws Exception{
     
        try{
     
            method3();
        }catch(Exception exc){
     
            throw new Exception("异常来自method2()方法",exc);
        }
    }

    public static void method1() throws Exception{
     
        try{
     
            method2();
        }catch(Exception ex){
     
            throw new Exception("异常来自method1()方法",ex);
        }
    }

    public static void main(String[] args) {
     
        try{
     
            method1();
        }catch(Exception e){
     
            e.printStackTrace();
        }
    }
}

一篇文章带你理解并掌握Java的异常_第4张图片

八、创建自定义异常类

可以通过继承Java.lang.Exception类来定义一个自定义异常类。

Java提供相当多的异常类,尽量使用它们而不要创建自己的异常类。如果遇到一个不能用预定义异常类来充分描述的问题,那就可以通过继承Exception类或其子类来创建自己的异常类。

/**
 * @author MNH
 * @version 1.0
 * @project Name: JAVA基础
 * @file Name: InvalidRadiusException
 * @desc 功能描述
 * @by IDE: IntelliJ IDEA
 */
public class InvalidRadiusException extends Exception{
     
    private double radius;

    public InvalidRadiusException(double radius){
     
        super("Invalid radius:"+radius);
        this.radius=radius;
    }

    public double getRadius(){
     
        return radius;
    }
}

这个自定义异常类继承自java.lang.Exception,而Exception类继承自java.lang.Throwable,Exception类中的所有方法(例如,getMessage()、toString()、printStackTrace())都是从Throwable继承而来。

Exception类的构造方法:
Exception():构建一个没有信息的异常
Exception(String message):构建一个给定信息的异常
Exception(String message,Exception cause):构建一个具有指定信息和子句的异常,这形成了一个链式异常

/**
 * @author MNH
 * @version 1.0
 * @project Name: JAVA基础
 * @file Name: TestCircleWithCustomException
 * @desc 功能描述
 * @by IDE: IntelliJ IDEA
 */
public class TestCircleWithCustomException {
     
    public static void main(String[] args) {
     
        try {
     
            CircleWithCustomException circle1 = new CircleWithCustomException(2);
            CircleWithCustomException circle2 = new CircleWithCustomException(-2);
            CircleWithCustomException circle3 = new CircleWithCustomException();
        } catch (InvalidRadiusException ex) {
     
            System.out.println(ex);
        }
        System.out.println("创建圆的个数:" + CircleWithCustomException.getNumberOfCircle());
    }
}

class CircleWithCustomException {
     
    private double radius;

    private static int numberOfCircle = 0;

    public CircleWithCustomException(double radius) throws InvalidRadiusException {
     
        setRadius(radius);
        numberOfCircle++;
    }

    public CircleWithCustomException() throws InvalidRadiusException {
     
        this(0);
    }

    public void setRadius(double radius) throws InvalidRadiusException {
     
        if (radius >= 0) {
     
            this.radius = radius;
        } else {
     
            throw new InvalidRadiusException(radius);
        }
    }

    public double getRadius() {
     
        return radius;
    }

    public static int getNumberOfCircle() {
     
        return numberOfCircle;
    }

    public double area() {
     
        return 3.14 * radius * radius;
    }
}

在这里插入图片描述
也可以继承RuntimeException声明一个自定义类异常,但这不是一个好方法,因为这会使自定义异常成为免检异常。最好使自定义异常是必检的,这样编译器就可以在程序中强制捕获这些异常。

你可能感兴趣的:(Java,java)