javase学习——异常

1. 异常概述

1.1 什么是异常

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

  • 异常 :指的是程序在执行过程中,出现的非正常的情况,如果不处理最终会导致JVM的非正常停止。

1.2 异常体系

1. Throwable

java.lang.Throwable 类是 Java 语言中所有错误或异常的超类。

  • 只有当对象是此类(或其子类之一)的实例时,才能通过 Java 虚拟机或者 Java 的throw 语句抛出。类似地,只有此类或其子类之一才可以是 catch 子句中的参数类型。

Throwable中的常用方法:

  • public void printStackTrace():打印异常的详细信息。

    包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace。

  • public String getMessage():获取发生异常的原因。

    提示给用户的时候,就提示错误原因。

2. Error和Exception

Throwable有两个直接子类:java.lang.Errorjava.lang.Exception,平常所说的异常指java.lang.Exception

  • Error:表示严重错误,一旦发生必须停下来查看问题并解决问题才能继续,无法仅仅通过try…catch解决的错误。(如果拿生病做比喻,就像是突发疾病,而且是危重症,必须立刻停下来治疗而不是靠短暂休息、吃药、打针、或小手术简单解决处理)
    • 例如:StackOverflowError(栈内存溢出)和OutOfMemoryError(堆内存溢出,简称OOM)。
  • Exception:表示普通异常,其它因编程错误或偶然的外在因素导致的一般性问题,程序员可以通过代码的方式检测、提示和纠正,使程序继续运行,但是只要发生也是必须处理,否则程序也会挂掉。(这就好比普通感冒、阑尾炎、牙疼等,可以通过短暂休息、吃药、打针、或小手术简单解决,但是也不能搁置不处理,不然也会要人命)。
    • 例如:空指针访问、试图读取不存在的文件、网络连接中断、数组下标越界等

1.3 受检异常和非受检异常

我们平常说的异常就是指Exception,根据代码的编写编译阶段,编译器是否会警示当前代码可能发生xx异常,并督促程序员提前编写处理它的代码为依据,可以将异常分为:

  • 编译时期异常(即checked异常、受检异常):在代码编译阶段,编译器就能明确警示当前代码可能发生(不是一定发生)xx异常,并督促程序员提前编写处理它的代码。如果程序员不听话,没有编写对应的异常处理代码,则编译器就会发威,直接判定编译失败,从而程序无法执行。通常,这类异常的发生不是由程序员的代码引起的,或者不是靠加简单判断就可以避免的,例如:FileNotFoundException(文件找不到异常)。
  • 运行时期异常(即runtime异常、unchecked非受检异常):即在代码编译阶段,编译器完全不做任何检查,无论该异常是否会发生,编译器都不给出任何提示。只有等代码运行起来并确实发生了xx异常,它才能被发现。通常,这类异常是由程序员的代码编写不当引起的,只要稍加判断,或者细心检查就可以避免的。例如:ArrayIndexOutOfBoundsException数组下标越界异常,ClassCastException类型转换异常。

2. 异常处理

Java异常处理的五个关键字:try、catch、finally、throw、throws

2.1 try…catch

基本格式

try{
     可能发生xx异常的代码
}catch(异常类型1  e){
     处理异常的代码1
}catch(异常类型2  e){
     处理异常的代码2
}
....

try{}中编写可能发生xx异常的业务逻辑代码。

catch分支,分为两个部分,catch()中编写异常类型和异常参数名,{}中编写如果发生了这个异常,要做什么处理的代码。如果有多个catch分支,并且多个异常类型有父子类关系,必须保证小的子异常类型在上,大的父异常类型在下。

当某段代码可能发生异常,不管这个异常是编译时异常(受检异常)还是运行时异常(非受检异常),我们都可以使用try块将它括起来,并在try块下面编写catch分支尝试捕获对应的异常对象。

  • 如果在程序运行时,try块中的代码没有发生异常,那么catch所有的分支都不执行。
  • 如果在程序运行时,try块中的代码发生了异常,根据异常对象的类型,将从上到下选择第一个匹配的catch分支执行。此时try中发生异常的语句下面的代码将不执行,而整个try…catch之后的代码可以继续运行。
  • 如果在程序运行时,try块中的代码发生了异常,但是所有catch分支都无法匹配(捕获)这个异常,那么JVM将会终止当前方法的执行,并把异常对象“抛”给调用者。如果调用者不处理,程序就挂了。
    示例代码:
public class TestTryCatch {
    public static void main(String[] args) {
        try {
            int a = Integer.parseInt(args[0]);
            int b = Integer.parseInt(args[1]);
            int result = a/b;
            System.out.println("result = " + result);
        } catch (NumberFormatException e) {
            System.out.println("数字格式不正确,请输入两个整数");
        } catch (ArrayIndexOutOfBoundsException e){
            System.out.println("数字个数不正确,请输入两个整数");
        } catch (ArithmeticException e){
            System.out.println("第二个整数不能为0");
        }

        System.out.println("你输入了" + args.length +"个参数。");
        System.out.println("你输入的被除数和除数分别是:");
        for (int i = 0; i < args.length; i++) {
            System.out.print(args[i]+"  ");
        }
        System.out.println();
    }
}

2.2 try…catch…finally

基本格式

try{
     
 }catch(...){
     
 }finally{
     无论try中是否发生异常,也无论catch是否捕获异常,也不管trycatch中是否有return语句,都一定会执行
 }try{
     
 }finally{
     无论try中是否发生异常,也不管try中是否有return语句,都一定会执行。
 } 

如果finally中写了return语句,那么try和catch中的return语句就失效了,最终返回的是finally块中的

2.3 throws

2.3.1 throws编译时异常

如果在编写方法体的代码时,某句代码可能发生某个编译时异常,不处理编译不通过,但是在当前方法体中可能不适合处理或无法给出合理的处理方式,就可以通过throws在方法签名中声明该方法可能会发生xx异常,需要调用者处理。

声明异常格式:

修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2…{   }	

其中,throws后面可以写多个异常类型,需要用逗号隔开

public class TestThrowsCheckedException {
    public static void main(String[] args) {
        System.out.println("上课.....");
        try {
            afterClass();//换到这里处理异常
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("准备提前上课");
        }
        System.out.println("上课.....");
    }

    public static void afterClass() throws InterruptedException {
        for(int i=10; i>=1; i--){
            Thread.sleep(1000);//本来应该在这里处理异常
            System.out.println("距离上课还有:" + i + "分钟");
        }
    }
}

2.3.2 throws运行时异常

当然,throws后面也可以写运行时异常类型,只是运行时异常类型,写或不写对于编译器和程序执行来说都没有任何区别。如果写了,唯一的区别就是调用者调用该方法后,使用try…catch结构时,IDEA可以获得更多的信息,需要添加什么catch分支。

public class TestThrowsRuntimeException {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        try {
            System.out.print("请输入第一个整数:");
            int a = input.nextInt();
            System.out.print("请输入第二个整数:");
            int b = input.nextInt();
            int result = divide(a,b);
            System.out.println(a + "/" + b +"=" + result);
        } catch (ArithmeticException | InputMismatchException e) {
            e.printStackTrace();
        } finally {
            input.close();
        }
    }

    public static int divide(int a, int b)throws ArithmeticException{
        return a/b;
    }
}

2.3.3 方法重写对于throws要求

方法重写时,对于方法签名是有严格要求的:

(1)方法名必须相同

(2)形参列表必须相同

(3)返回值类型

  • 基本数据类型和void:必须相同
  • 引用数据类型:<=

(4)权限修饰符:>=,而且要求父类被重写方法在子类中是可见的

(5)不能是static,final修饰的方法

(6)throws异常列表要求

  • 如果父类被重写方法的方法签名后面没有 “throws 编译时异常类型”,那么重写方法时,方法签名后面也不能出现“throws 编译时异常类型”。
  • 如果父类被重写方法的方法签名后面有 “throws 编译时异常类型”,那么重写方法时,throws的编译时异常类型必须<=被重写方法throws的编译时异常类型,或者不throws编译时异常。
  • 方法重写,对于“throws 运行时异常类型”没有要求。

2.3.4 手动抛出异常对象:throw

Java程序的执行过程中如出现异常,会生成一个异常类对象,该异常对象将被提交给Java运行时系统,这个过程称为抛出(throw)异常。异常对象的生成有两种方式:

  • 由虚拟机自动生成:程序运行过程中,虚拟机检测到程序发生了问题,就会在后台自动创建一个对应异常类的实例对象并抛出——自动抛出。
  • 由开发人员手动创建:new 异常类型(【实参列表】);,如果创建好的异常对象不抛出对程序没有任何影响,和创建一个普通对象一样,但是一旦throw抛出,就会对程序运行产生影响了。

使用格式:

throw new 异常类名(参数);

throw语句抛出的异常对象,和JVM自动创建和抛出的异常对象一样。

  • 如果是编译时异常类型的对象,同样需要使用throws或者try…catch处理,否则编译不通过。
  • 如果是运行时异常类型的对象,编译器不提示。
  • 但是无论是编译时异常类型的对象,还是运行时异常类型的对象,如果没有被try…catch合理的处理,都会导致程序崩溃。

throw语句会导致程序执行流程被改变,throw语句是明确抛出一个异常对象,因此它下面的代码将不会执行,如果当前方法没有try…catch处理这个异常对象,throw语句就会代替return语句提前终止当前方法的执行,并返回一个异常对象给调用者。

public class TestThrow {
    public static void main(String[] args) {
        try {
            System.out.println(max(4,2,31,1));
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            System.out.println(max(4));
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            System.out.println(max());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static int max(int... nums){
        if(nums == null || nums.length==0){
            throw new IllegalArgumentException("没有传入任何整数,无法获取最大值");
        }
        int max = nums[0];
        for (int i = 1; i < nums.length; i++) {
            if(nums[i] > max){
                max = nums[i];
            }
        }
        return max;
    }
}

3. 自定义异常

3.1 如何定义异常类

  1. 自定义一个编译时异常类型:自定义类 并继承java.lang.Exception
  2. 自定义一个运行时异常类型:自定义类 并继承java.lang.RuntimeException

注意自定义的异常只能通过throw抛出。

自定义异常:

(1)要继承一个异常类型

(2)建议大家提供至少两个构造器,一个是无参构造,一个是(String message)构造器

(3)自定义异常对象只能手动抛出。抛出后由try…catch处理,也可以甩锅throws给调用者处理。

你可能感兴趣的:(学习,java,jvm)