Java 异常处理机制

最新推荐文章于 2021-02-27 11:06:43 发布
最新推荐文章于 2021-02-27 11:06:43 发布
阅读量184 收藏
点赞数
分类专栏： Java 文章标签： 异常
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ty6693/article/details/100066617
版权

一、产生原因

代码运行过程中可能会出现异常，为了保证程序在出现异常后能够正确执行完毕，就需要进行异常处理。

二、异常的继承结构

Throwable是所有异常的父类

 

其有两个子类：Error和Exception

 

 

而对于Exception类来说，它又有两个子类：RuntimeException和IOException

 

 

继承类结构：

 

其中，

Error描述的是Java运行时内部错误和资源耗尽错误。应用程序不抛出此类异常，这种异常一旦发生，除了告知用户并使程序安全终止外，再无能为力。

Exception的两个子类：

RuntimeException描述的是由于程序内部错误导致的异常。比如ArrayIndexOutOfBoundsException【数组下标越界异常】、ArithmeticException【算术异常，比如除数为0的情况】、NullPointerException【空指针异常】、ClassCastException【强制类型转换异常】等。

IOException描述的是程序本身没有问题，而由IO错误导致的异常。比如FileNotFoundException【文件找不到异常】、FileAlreadyExistsException【文件已存在异常】等。

另外，我们把派生于Error类和RuntimeException类的异常称为非受查异常，也叫运行时异常；其它异常称为受查异常，也叫检查异常。

三、异常处理格式

try{

//有可能出现异常的语句

}catch(异常类 对象){

//异常信息

}finally{

//无论是否发生异常，都会执行到

}

三种组合方式：try...catch...、try...finally...、try...catch...finally

import java.util.Scanner;

public class Test {
	public int calculate(int x, int y){
        return x / y;
    }

    public static void main(String[] args) {
        //1. try...catch
//        Test test = new Test();
//        Scanner scanner = new Scanner(System.in);
//        while (scanner.hasNext()) {
//            int x = scanner.nextInt();
//            int y = scanner.nextInt();
//            try {
//                System.out.println(test.calculate(x, y));
//            } catch (Exception e) {
//                e.printStackTrace();
//            }
//        }

        //2. try...finally
//        Test test = new Test();
//        Scanner scanner = new Scanner(System.in);
//        while (scanner.hasNext()) {
//            int x = scanner.nextInt();
//            int y = scanner.nextInt();
//            try {
//                System.out.println(test.calculate(x, y));
//            } finally {
//                System.out.println("计算完毕");
//            }
//        }

         //3.try...catch...finally
        Test test = new Test();
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            int x = scanner.nextInt();
            int y = scanner.nextInt();
            try {
                System.out.println(test.calculate(x, y));
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                System.out.println("计算完毕");
            }
        }
    }
}

当然，如果出现异常了，不想进行处理的话，就可以使用throws关键字将异常抛出。告诉调用者本方法有可能产生的异常，并且调用者在调用此方法时，必须使用try...catch捕获异常。

import java.util.Scanner;

public class Test {
	public int calculate(int x, int y) throws Exception {
        return x / y;
    }

    public static void main(String[] args) {
		Test test = new Test();
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            int x = scanner.nextInt();
            int y = scanner.nextInt();
            try {
                System.out.println(test.calculate(x, y));
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                System.out.println("计算完毕");
            }
        }
    }
}

注：如果主方法上有throws关键字的话，那么此时如果出现了异常，就会交给JVM去处理。

如果想手动抛出异常但是有时候有些异常在JVM看来不是异常的情况下，就可以使用throw。比如说年龄出现负数的情况，此时在JVM看来并不是异常，但是实际中年龄不可能为负数，所以此时需要我们手动抛出异常。

public class Test {
    int age = 0;

    public void test() {
        age = -1;
        if (age < 0) {
            try {
                throw new Exception("年龄为负数啦！");
            } catch (Exception e) {
                e.printStackTrace();
            }
        } else {
            System.out.println(age);
        }
    }

    public static void main(String[] args) {
        Test t = new Test();
        t.test();
    }

}

反编译某个java文件：

  1. 右击该文件名，点击Open in terminal
  2. 输入javac 文件名.java（编译）
  3. 输入javap -v 文件名（反编译）
  4. 点击此时生成的文件名.class文件，就可以看到反编译后的文件

四、关于try...catch...finally使用时的一些特殊情况解读【含return语句】

代码1：

public class Test {
	//此时的执行顺序：
	//1.执行try块中的i=1以及return i语句，并暂存i值【1】
	//2.执行finally块中的i=3语句
	//3.返回try块的return语句，并返回此时暂存的i值【1】
    public int test() {
        int i = 0;
        try {
            i = 1;
            return i;
        } catch (Exception e) {
            i = 2;
            return i;
        } finally {
            i = 3;
        }

    }

    public static void main(String[] args) {
        Test t = new Test();
        System.out.println(t.test());    //1
    }
}

代码2：

public class Test {

    //此时的执行顺序：
	//1.执行try块中的i=1以及return i语句,此时的i=1
	//2.执行finally块中的i=3以及return i语句，此时的i=3
	//3.返回finally块中的return语句，返回此时的i值【i=3】
    public int test() {
        int i = 0;
        try {
            i = 1;
            return i;
        } catch (Exception e) {
            i = 2;
            return i;
        } finally {
            i = 3;
            return i;
        }

    }

    public static void main(String[] args) {
        Test t = new Test();
        System.out.println(t.test());   //3
    }
}

代码3：

public class Test {

    int age;
    //此时的执行顺序：
	//1. 产生一个对象
	//2. 执行try块中的test.age=10以及return test语句
	//3. 执行finally块中的test=new Test()以及test.age=30语句  此时产生了另一个对象，并对另一个对象的age属性做了修改
	//4. 返回try块的return语句，返回第1个对象
    public static Test test() {
        Test test = new Test();
        try {
            test.age = 10;
            return test;
        }catch (Exception e) {
            test.age = 20;
            return test;
        }finally {
            test = new Test();
            test.age = 30;
        }
    }
	
	public static void main(String[] args) {
        System.out.println(test().age);  //10
    }
}

代码4：

public class Test {

    int age;
    public static void main(String[] args) {
        System.out.println(test().age);  //30
    }
	
	//此时的执行顺序：
	//1. 产生一个对象
	//2. 执行try块中的test.age=10以及return test语句
	//3. 执行finally块中的test=new Test()以及test.age=30语句  此时产生了另一个对象，并对另一个对象的age属性做了修改
	//4. 返回finally块的return语句，返回第2个对象
    public static Test test() {
        Test test = new Test();
        try {
            test.age = 10;
            return test;
        }catch (Exception e) {
            test.age = 20;
            return test;
        }finally {
            test = new Test();
            test.age = 30;
            return test;
        }
    }
}

代码5：

public class Test {

    int age;
    public static void main(String[] args) {
        System.out.println(test().age);  //30
    }
	
	//此时的执行顺序：
	//1. 产生一个对象
	//2. 执行try块中的test.age=10以及return test语句
	//3. 执行finally块中的test.age=30语句  对同一个对象的age属性做了修改
	//4. 返回try块的return语句，返回该对象
    public static Test test() {
        Test test = new Test();
        try {
            test.age = 10;
            return test;
        }catch (Exception e) {
            test.age = 20;
            return test;
        }finally {
            test.age = 30;
        }
    }
}

代码6：

public class Test {

    int age;
    public static void main(String[] args) {
        System.out.println(test().age);  //30
    }
	
	//此时的执行顺序：
	//1. 产生一个对象
	//2. 执行try块中的test.age=10以及return test语句
	//3. 执行finally块中的test.age=30语句  对同一个对象的age属性做了修改
	//4. 返回finally块的return语句，返回该对象
    public static Test test() {
        Test test = new Test();
        try {
            test.age = 10;
            return test;
        }catch (Exception e) {
            test.age = 20;
            return test;
        }finally {
            test.age = 30;
            return test;
        }
    }
}

 

操作的变量是局部变量的情况下

1. try和finally块中都有return语句

不论try块和finally块中改变的是否是同一个局部变量，返回的都是finally块中对该块中局部变量的修改值

2. try中有return语句，finally中没有return语句

不论try块和finally块中改变的是否是同一个局部变量，返回的都是try块中对该块中局部变量的修改值

 

操作的变量是成员变量的情况下

1. try和finally块中都有return语句

不论try块和finally块中改变的是否是同一个对象的成员变量，返回的都是finally块中对对象成员变量的修改值

2. try中有return语句，finally中没有return语句

第一种情况：try块和finally块中改变的是同一个对象的成员变量，那么finally块中对该成员变量的修改会影响try块的return语句

第二种情况：try块和finally块中改变的不是同一个对象的成员变量，那么finally块中对该成员变量的修改不会影响try块的return语句

 

总结：只要finally块中有return语句，那么最终执行的return语句永远是finally块中的；如果finally块中没有return语句，那么此时要看try块和finally块操作的是否是同一个对象的同一个成员变量，如果是，那么finally块对该成员变量的修改会影响到try中的return语句；否则，不论此时finally块中操作的是同一个对象的不同成员变量，还是不同对象的成员变量，还是只是一个局部变量，都不会对try中的return语句产生影响。

ty6693
关注
专栏目录
Java基础篇：异常处理
HTZW的博客
05-07 483
文章目录异常概述与异常体系结构常见异常异常处理机制异常处理机制一：try-catch-finally异常处理机制二：throws手动抛出异常:thow如何自定义一个异常类？总结 异常概述与异常体系结构 异常：在Java语言中，将程序执行中发生的不正常情况称为“异常”。(开发过程中的语法错误和逻辑错误不是异常) Java程序在执行过程中所发生的异常事件可分为两类： Error：Java虚...
Java异常处理机制
hangshao的博客
03-27 280
我们平时程序中都遇到过异常处理的问题，今天抽时间总结下java的异常处理机制。 首先我们来看异常的分类： Error 系统级别的错误： Java 运行时环境出现的错误，不可控。 Exception 是程序级别的错误：编译阶段的错误，可控。 异常结构中的父类 Throwable 类，其下子类 Exception类和 Error 类。我们在程序中可以捕获的是 Exception 的子类
java 数组下标越界异常（ArrayIndexOutOfBoundsException）
06-18
java 数组下标越界异常（ArrayIndexOutOfBoundsException） java 数组下标越界异常（ArrayIndexOutOfBoundsException）
数组下标越界异常
叫我匪爷吧
03-31 4920
java.lang.ArrayIndexOutOfBoundsException ：数组下标越界
C语言获取数组越界，除以零等异常
tiandyoin的专栏
11-24 1064
#pragma once #include &lt;windows.h&gt; #include &lt;tchar.h&gt; #include &lt;stdio.h&gt; //需求安装windows sdk #define MAX_PATH 260 #define STATUS_POSSIBLE_DEADLOCK ((unsigned long)0xC0000194L) #def...
14.java异常处理机制.zip
最新发布
06-15
14.java异常处理机制.zip14.java异常处理机制.zip14.java异常处理机制.zip14.java异常处理机制.zip14.java异常处理机制.zip14.java异常处理机制.zip14.java异常处理机制.zip14.java异常处理机制.zip14.java异常处理...
深入理解java异常处理机制Java开发Java经验技巧共
11-22
Java异常处理机制是Java编程中不可或缺的一部分，它提供了一种有序地处理程序错误和异常情况的方法。这篇19页的PDF文档《深入理解java异常处理机制Java开发Java经验技巧共》可能涵盖了Java异常处理的基本概念、最佳...
异常的捕获与处理
学习笔记
09-26 920
异常机制: 异常指程序运行过程中出现的非正常现象,例如用户输入错误、除数为零、需要处理的文件不存在、数组下标越界等. 在Java的异常处理机制中,引进了很多用来描述和处理异常的类,称为异常类.异常类定义中包含了该类异常的信息和对异常进行处理的方法. 所谓异常处理,就是指程序在出现问题时依然可以正确的执行完. Java是采用面向对象的方式来处理异常的.处理过程: 1. 抛出异常:在执行一个方法时,如果发生异常,则这个方法生成代表该异常的一个对象,停止当前执行路径,并把异常对象提交给JRE.
python-异常
wuxingge的博客
09-11 729
异常 程序在运行过程中，不可避免的出现一些错误 没有赋值的变量 使用了不存在的索引 除0 … 这些错误在程序中，称为异常 程序运行过程中，一旦出现异常将会导致程序立即终止，异常之后的代码全部不执行 处理异常 程序运行出现异常，目的不是让程序直接终止 在出现异常时，可以编写代码来对异常进行处理 try语句 语法： try: 代码块(可能出现错误的语句) except: 代码块(出现错误以后的处理方式) else: 代码块(没出错时要执行的语句) 可以将可能出错的代码放
java数组下标越界处理_可恶的Java数组下标越界检查
weixin_31621945的博客
02-13 656
刚刚学习Java不到一个星期，本来是搞C++的，没事学习Java，将来可以更好的想Android方向发展一下。现在正处于磨基础的阶段，对与每一个新手来书，最痛苦的莫过于此了。写了一个冒泡排序，用C++的思想写，没有任何错误，但是改成Java就出现如下错误：Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 7at...
《java程序设计基础》异常的处理
qq_45724328的博客
11-13 990
异常的产生 输入一个数组的所有元素，捕捉数组下标越界异常和除数为0异常 package practice; public class y { public static void main(String[] args) { // TODO Auto-generated method stub int i; int []a = {1,2,3,4}; for(i=0;i<5;i++){ System.out.println(" a["+i+"]="+a[i]); System.out.pri
异常-异常的捕捉与处理
cntakeshi的博客
12-20 989
任务描述： 定义并初始化一个包含10个整型元素的数组； 定义一个search(int[] arr, int x)方法，根据索引号x在数组中找出下标为x的数组元素，并返回该元素的值。 从键盘输入一个索引号，调用search方法，输出索引号对应的数组元素的值。 捕捉并处理输入索引号类型不匹配异常（ InputMismatchException ）和数组下标越界异常（ArrayIndexOutOfBoundsException）。 public class Exception{ public static
java自定义异常除数为零_java系列10：异常（Exception）
weixin_35780426的博客
02-26 2569
1、生活中的异常2、异常程序中出现的错误被称为异常。异常可分为两大类：编译时异常和运行时异常。异常就是在程序的运行过程中所发生的不正常的事件，它会中断正在运行的程序。编译时异常一般是指语法错误，可以通过编译器的提示加以修正；运行时异常包括：运行错误：如数组下标越界，除数为0等；逻辑错误：如年龄超过200岁等。3、发生异常的原因多种多样，主要有：系统资源不可用：如内存分配失败，文件打开失败，数据源连...
java捕获数组下标异常代码_多线程中ArrayList调用Add()添加元素时的下标越界问题(java.lang.ArrayIndexOutOfBoundsException)...
weixin_33435115的博客
02-27 637
问题：在多线程中使用ArrayList调用Add()添加元素时，有时候会出现下面的错误Exception in thread "Thread-1" Exception in thread "Thread-2" java.lang.ArrayIndexOutOfBoundsException: 15at java.util.ArrayList.elementData(ArrayList.java:4...
JAVA项目常用异常处理汇总
TX的博客
10-09 776
　1.空指针异常（java.lang.nullpointerexception） 发生该情况一般是字符串变量未初始化，数组未初始化，类对象未初始化等。还有一种情况是当该对象为空时你并没有判断是否为空值，这个错误我在之前的web习题上犯过，因此为了避免这种情况，除了检查是否初始化之外，如有必要则要加上判断是否为null的if语句。 　　2.指定的类不存在（java.lang.ClassNotFoundException） 出现这个错误的原因之一是缺包，这时只要下载并导入相应的包即可；当我们已经把包导入的
java除数为0异常处理_java实例_出错处理 [超过1000&除数为零]
weixin_31545945的博客
02-15 4789
Java 提供了异常处理机制，当程序中发生异常时，程序产生一个异常事件，相应地生成异常对象。系统从生成对象的代码开始，沿方法的调用栈逐层回溯，寻找相应的处理代码，并把异常对象交给该方法处理。1.新建一个 project，在 main 里面输入以下程序：String output[] = {"The ","quick ","brown ","fox ","jumps ","over ","the "...
数组中的常见异常
qq_44739966的博客
11-05 670
数组中的常见异常： 1.数组角标越界的异常：ArrayIndexOutOfBoundsException 2.空指针异常：NullPointerException 注意：一旦程序出现异常，未处理，程序将中止执行。 package day07; /* 数组中的常见异常： 1.数组角标越界的异常：ArrayIndexOutOfBoundsException 2.空指针异常：NullPointerException 注意：一旦程序出现异常，未处理，程序将中止执行。 */ public class ArrayEx
Java异常处理机制详解
Java异常处理包含两个关键步骤：抛出异常和捕获异常。抛出异常时，当语义限制被违反，系统会产生一个异常对象并提交给运行系统。捕获异常则是在异常发生后，系统会沿方法调用栈向上回溯，直到找到合适的异常处理代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值