Java 异常

合集下载

Java异常面试题 33道

Java异常架构与异常关键字1. Java异常简介Java异常是Java提供的一种识别及响应错误的一致性机制。

Java异常机制可以使程序中异常处理代码和正常业务代码分离，保证程序代码更加优雅，并提高程序健壮性。

在有效使用异常的情况下，异常能清晰的回答what, where, why这3个问题：异常类型回答了“什么”被抛出，异常堆栈跟踪回答了“在哪”抛出，异常信息回答了“为什么”会抛出。

2. Java异常架构1. ThrowableThrowable 是 Java 语言中所有错误与异常的超类。

Throwable 包含两个子类：Error（错误）和 Exception（异常），它们通常用于指示发生了异常情况。

Throwable 包含了其线程创建时线程执行堆栈的快照，它提供了 printStackTrace() 等接口用于获取堆栈跟踪数据等信息。

2. Error（错误）定义：Error 类及其子类。

程序中无法处理的错误，表示运行应用程序中出现了严重的错误。

特点：此类错误一般表示代码运行时 JVM 出现问题。

通常有 Virtual MachineError（虚拟机运行错误）、NoClassDefFoundError（类定义错误）等。

比如 OutOfMemoryError：内存不足错误；StackOverﬂowError：栈溢出错误。

此类错误发生时，JVM 将终止线程。

这些错误是不受检异常，非代码性错误。

因此，当此类错误发生时，应用程序不应该去处理此类错误。

按照Java惯例，我们是不应该实现任何新的Error子类的！3. Exception（异常）程序本身可以捕获并且可以处理的异常。

Exception 这种异常又分为两类：运行时异常和编译时异常。

运行时异常定义：RuntimeException 类及其子类，表示 JVM 在运行期间可能出现的异常。

特点：Java 编译器不会检查它。

也就是说，当程序中可能出现这类异常时，倘若既"没有通过throws声明抛出它"，也"没有用try-catch语句捕获它"，还是会编译通过。

java异常处理方法及流程

java异常处理方法及流程Java 异常处理方法及在 Java 编程中，异常处理是一项非常重要的技术。

通过适当的异常处理方法，可以使程序具备更好的稳定性和可读性，提高程序的健壮性。

本文将详细介绍 Java 异常处理的各个流程。

异常的基本概念异常是在程序执行期间产生的一种错误或异常情况。

Java 引入了异常处理机制来处理这些异常，以提高程序的可靠性和可维护性。

异常分为两种类型：1.受检异常（Checked Exceptions）：受检异常在编译阶段必须进行处理，否则编译器将报错。

例如，IOException 是常见的受检异常。

2.非受检异常（Unchecked Exceptions）：非受检异常是指不需要显式捕获或声明抛出的异常，编译器不会检查是否对其进行处理。

例如，NullPointerException 是常见的非受检异常。

异常处理的方法Java 提供了多种处理异常的方法，包括捕获异常和抛出异常。

下面分别进行介绍。

捕获异常是指通过使用try-catch语句块来捕获并处理异常。

try语句块用于包裹可能出现异常的代码，catch语句块用于捕获并处理异常。

try {// 可能抛出异常的代码块// ...} catch (ExceptionType1 e1) {// 处理异常类型1// ...} catch (ExceptionType2 e2) {// 处理异常类型2// ...} finally {// 可选的 finally 代码块，始终会被执行// ...}抛出异常当一个方法无法处理某个异常时，可以通过throw关键字手动抛出异常。

异常将会被传递给调用该方法的代码，并进一步处理。

public void someMethod() throws SomeException {if (someCondition) {throw new SomeException("Some error message");}使用异常的注意事项在使用异常处理时，需要注意以下几点：•捕获异常的顺序非常重要，应该从特定异常到一般异常的顺序进行捕获。

Java中的异常现象

Java中的异常现象一、基本异常异常情形:指引发阻止当前方法或作用域继续执行的问题.普通问题:在当前环境下能得到足够的信息,总能处理这个错误.而异常情形就不同了.发生了异常后,不能继续下去,因为在当前环境下无法获得必要的信息来解决当前的问题.你所能做的就是从当前环境跳出,并且把问题提交给上一级环境,这一动作就是抛出异常.抛出异常所做的动作:1、用new在堆上创建对象.2、当前执行的程序被终止,从当前环境中弹出对象的引用.此时,由异常处理机制接管程序,并开始寻找一个恰当的地方来执行程序.这个地方就是”异常处理程序”,它的任务就是将程序从错误状态中恢复,以使程序要么换一种方式运行,要么继续运行下去.注意:抛出异常是由方法抛出的.异常也是一个类!并用这个类在堆上建立对象.所有的异常类都有两个构造器:1、缺省的构造器Exception();2、带参数的构造器Exception()的括弧中加上参数.注：要定义自己的异常类，必须从已有的异常类继承。

二、捕获异常如果方法要抛出异常,它必须假定异常将被”捕获”并得到处理.异常处理的好处之一:在一个地方编写解决问题的代码,然后在别的地方处理这些代码的错误。

首先什么是”监控区域”?它是一段可能产生异常的代码.并且后面跟着处理这些异常的代码.也就是try{//可能产生异常的语句放在此处!//在此处捕获异常}三、异常处理程序抛出的异常必须处理,这个地方就是异常处理程序.用catch表示.完整的代码如下:try{}catch(type xx){}异常处理也可以有多个catch!异常处理程序必须紧跟在try块之后,异常处理机制将负责搜索同发生异常的第一个相匹配的程序.一旦catch子句结束,则处理程序的查找过程结束.只有匹配的catch子句才能得到执行.四、终止和恢复异常处理有两种模型:终止:一旦异常抛出,就表明错误无法挽回,也不能继续执行.恢复:异常处理程序可以修正错误.然后重新尝试调用出现问题的方法.(解决办法:将出现异常的语句放在while循环中.)终止模型是今后的重点!而不要考虑恢复模型注意：1:main()作为一个方法也可以有异常说明,这里的异常的类型是Exception,它也是所有”被检查的异常”的基类.通过把它传递到控制台,就不必在main()里写try-catch子句了.尽管很方便,但这不是通用的做法.2:java语言中采用try-catch-finally结构处理异常.一个try-catch-finally结构中,必须有try 语句块,catch语句块.finally语句块不是必须的,但至少要两者取其一.如果3个语句块均存在,一定要按照try/catch/finally的顺序排列.3:catch语句块可以有多个,各catch语句块用于捕获不同的异常.如果try块中的语句在执行时发生异常,则执行从该处中断而进入catch块,根据异常的类型进行匹配,顺序在前的catch块优先进行匹配比较,只要该异常是catch中指定的异常类或其子类就匹配成功,进而执行相应的catch中的内容.4:不管在try语句块中是否抛出异常,也不管catch语句块是否捕获到异常,finally语句块中的内容都将继续被执行.注意,即使try语句块中包含return语句,也会先执行完finally语句块中的代码,再执行return语句返回方法值.5:只有执行System.exit()方法或出现Error错误时,finally语句块才不会获得执行而退出程序.6:如果没有异常出现或异常被捕获、处理,则在退出try-catch-finally结构后,会继续执行后续的代码.7:一个方法抛出异常声明时需分两步,第一步在方法名后采用throws语句声明抛出的异常,如果抛出多个异常,则在各个异常间使用逗号分隔.第二步是在方法体内部采用throw语句抛出异常,以便try语句块捕获.8:ng.Throwable类是所有异常和错误的顶层类.Throwable类有两个直接子类ng.Error和ng.Exception.Error类代表编译期和系统错误,程序员不需要处理它,Exception 类是可以从任何标准java类方法中抛出的基本类型异常,也是程序员需要处理的.注意,ng.RuntimeException异常类是由java虚拟机抛出的,不需要程序员处理.五、java标准异常Throwable这个java类被用来表示任何可以作为异常被抛出的类.它可以分Error用来表示编译时和系统错误,Exception是可以被抛出的基本类型.。

java中常见的五种异常

java中常见的五种异常
1.ClassCastException(类转换异常)
数据类型转换错误，比如有个String temp="abc"; 如果设为(int)temp就会报错了，因为它们类型不一样，但是设为(object)temp就可以，因为object是它们的父类
2.IndexOutOfBoundsException(数组越界)
这个异常我们在操作数组的时候会经常遇到，异常的解释是“数组下标越界“，现在程序中大多都有对数组的操作，因此在调用数组的时候一定要认真检查，看自己调用的下标是不是超出了数组的范围，一般来说，显示（即直接用常数当下标）调用不太容易出这样的错，但隐式（即用变量表示下标）调用就经常出错了，还有一种情况，是程序中定义的数组的长度是通过某些特定方法决定的，不是事先声明的，这个时候，最好先查看一下数组的length，以免出现这个异常。

3.NullPointerException(空指针)
这个异常在编程时也经常遇到，异常的解释是“程序遇上了空指针“，简单地说就是调用了未经初始化的对象或者是不存在的对象，这个错误经常出现在调用数组这些操作中，对数组操作中出现空指针，很多情况下是一些刚开始学习编程的人常犯的错误，即把数组。

Java异常——异常分类、声明检查型异常

Java异常——异常分类、声明检查型异常⼀、异常的分类1、在Java程序设计语⾔中，异常对象都是派⽣于Throwable类的⼀个类的实例。

如果Java的内置类不能满⾜需求，⽤户还可以创建⾃⼰的异常类。

2、异常分为两⽀，Error和Exception。

Error类层次描述了Java运⾏时系统的内部错误和资源耗尽错误。

这种情况很少出现，如果出现了这种情况，就只能通知⽤户并妥善地终⽌程序。

Exception类是应该重点关注的层次结构。

3、Exception类分解成两个分⽀：⼀⽀派⽣于RuntimeException，另⼀⽀派⽣于其他异常。

派⽣于RuntimeException的异常包括以下问题：“如果出现RuntimeException异常，那么⼀定是你的问题”☛错误的强制类型转换☛数组访问越界☛访问null指针不是派⽣于RuntimeException的异常包括以下问题：⼀般是I/O错误这类问题导致的☛试图超越⽂件末尾继续读取⽂件☛试图打开不存在的⽂件☛试图根据给定的字符串查找Class对象，⽽这个字符串表⽰的类不存在。

4、检查型异常和⾮检查型异常。

Java语⾔规范将派⽣于Error或RuntimeException类的所有异常称为⾮检查型异常（unchecked），所有其他类型的异常称为检查型异常（chcked）。

编译器会检查你是否为所有的检查型提供了异常处理器。

⼆、声明检查型异常public FileInputStream(String name)throws FileNotFoundException这个声明是标准类库中FileInputStream类的⼀个构造器的声明。

这个声明表⽰构造器根据给定的String参数产⽣⼀个FileInputStream对象，但也有可能抛出FileNotFoundException异常。

如果发⽣了糟糕的情况，构造器不会初始化⼀个新的FileInputStream对象，⽽是抛出⼀个FileNotFoundException类对象，如果抛出了这样⼀个异常对象，系统会开始搜索知道如何处理FileNotFoundException对象的异常处理器。

Java异常类型及处理

Java异常类型及处理⽬录⼀、异常定义⼆、异常的结构和分类三、异常的处理和捕获四、⾃定义异常五、异常的应⽤1.打印堆栈2.弹出流程六、注意点总结⼀、异常定义异常就是“意外、例外”的意思，也就是⾮正常情况。

异常本质上是程序上的错误，包括程序逻辑错误和系统错误。

异常的处理基本上就是⽤来兜底的，也是程序开发中程序不愿意看到的。

异常最基本的信息就是线程的堆栈信息。

⼆、异常的结构和分类Throwable主要分为Error和Exception。

错误：Error类以及他的⼦类的实例，代表了JVM本⾝的错误。

错误不能被程序员通过代码处理，躺平解决就好，不要反抗。

常见的错误有下⾯这些异常：Exception以及他的⼦类，代表程序运⾏时发送的各种不期望发⽣的事件。

可以被Java异常处理机制使⽤，是异常处理的核⼼，能在程序中解决的都不叫事。

常见的异常有这么多。

三、异常的处理和捕获异常想要处理肯定要先捕获到异常才可以，怎么捕获异常呐，Java给我提供了⼏个关键字，每个关键字怎么⽤呐？1、try,catch 就是直接捕获异常，catch 内的异常类型是能捕获的类型，⼀般如果有多个异常，从上到下的顺序是异常范围越来越⼤。

注：ErrorCodeException的定义可以参考⾃定义异常。

public static void second(String[] args) {try {throw new ErrorCodeException("1123");} catch (ErrorCodeException e) {e.printStackTrace();}catch (Exception e){e.printStackTrace();}}2、try catch finally 增加了finally关键字，就是在异常之后还能做⼀些事情，⽐如常见的关闭输⼊流，输出流，是程序最后的倔强。

public static String readFileContent(String fileName) {File file = new File(fileName);BufferedReader reader = null;StringBuffer sbf = new StringBuffer();try {reader = new BufferedReader(new FileReader(file));String tempStr;while ((tempStr = reader.readLine()) != null) {sbf.append(tempStr);}reader.close();return sbf.toString();} catch (IOException e) {e.printStackTrace();} finally {if (reader != null) {try {reader.close();} catch (IOException e1) {e1.printStackTrace();}}}return sbf.toString();}3、throw 主要⽤来创建⼀个异常，因为程序中可能需要抛出⼀个异常，⽐如我们游戏服务器游戏逻辑验证客户端参数不通过，会主动抛出⼀个⾃定义的异常4、throws 主要⽤在⽅法签名上，当我们读写⽂件或者反射的时候，如果不⽤try catch 就会发现⽅法签名后有⼀堆的异常需要处理。

Java常见异常（RuntimeException）详细介绍并总结

Java常见异常（RuntimeException）详细介绍并总结本⽂重在Java中异常机制的⼀些概念。

写本⽂的⽬的在于⽅便我很长时间后若是忘了这些东西可以通过这篇⽂章迅速回忆起来。

1. 异常机制1.1 异常机制是指当程序出现错误后，程序如何处理。

具体来说，异常机制提供了程序退出的安全通道。

当出现错误后，程序执⾏的流程发⽣改变，程序的控制权转移到异常处理器。

1.2 传统的处理异常的办法是，函数返回⼀个特殊的结果来表⽰出现异常（通常这个特殊结果是⼤家约定俗称的），调⽤该函数的程序负责检查并分析函数返回的结果。

这样做有如下的弊端：例如函数返回-1代表出现异常，但是如果函数确实要返回-1这个正确的值时就会出现混淆；可读性降低，将程序代码与处理异常的代码混爹在⼀起；由调⽤函数的程序来分析错误，这就要求客户程序员对库函数有很深的了解。

1.3 异常处理的流程1.3.1 遇到错误，⽅法⽴即结束，并不返回⼀个值；同时，抛出⼀个异常对象1.3.2 调⽤该⽅法的程序也不会继续执⾏下去，⽽是搜索⼀个可以处理该异常的异常处理器，并执⾏其中的代码2 异常的分类2.1 异常的分类2.1.1 异常的继承结构：基类为Throwable，Error和Exception继承Throwable，RuntimeException和IOException等继承Exception，具体的RuntimeException继承RuntimeException。

2.1.2 Error和RuntimeException及其⼦类成为未检查异常（unchecked），其它异常成为已检查异常（checked）。

2.2 每个类型的异常的特点2.2.1 Error体系 Error类体系描述了Java运⾏系统中的内部错误以及资源耗尽的情形。

应⽤程序不应该抛出这种类型的对象（⼀般是由虚拟机抛出）。

如果出现这种错误，除了尽⼒使程序安全退出外，在其他⽅⾯是⽆能为⼒的。

JAVA异常及解决方法

java异常及解决方法1:.BindException:Address already in use解决方法在网络编程中，特别是在短时间内new的网络连接太多，经常出现.BindException:Address already in use: JVM_Bind的异常，网络有很多介绍此异常的，通常都是在说是要使用的端口被别的程序已经使用，但有时并不是这个原因，通过仔细查找，找到一些很好的资料，在此将其一一记录下来。

短时间内new socket操作过多而socket.close()操作并不能立即释放绑定的端口而是把端口设置为TIME_WAIT状态过段时间(默认240s)才释放(用netstat-na可以看到)最后系统资源耗尽(windows上是耗尽了pool of ephemeral ports这段区间在1024-5000之间)Socket Remember that TCP guarantees all data transmitted will be delivered,if at all possible.When you close a socket,the server goes into aTIME_WAIT state,just to be really really sure that all the data hasgone through.When a socket is closed,both sides agree by sending messages to each other that they will send no more data.This,itseemed to me was good enough,and after the handshaking is done,the socket should be closed.The problem is two-fold.First,there is no2:.BindException:Address already in use:connect的问题大概原因是短时间内new socket操作很多,而socket.close()操作并不能立即释放绑定的端口,而是把端口设置为TIME_WAIT状态,过段时间(默认240s)才释放,(用netstat-na可以看到),最后系统资源耗尽(windows上是耗尽了pool of ephemeral ports,这段区间在1024-5000之间;)避免出现这一问题的方法有两个，一个是调高你的web服务器的最大连接线程数，调到1024,2048都还凑合，以resin 为例，修改resin.conf中的thread-pool.thread_max，如果你采用apache连resin的架构，别忘了再调整apache；另一个是修改运行web服务器的机器的操作系统网络配置，把time wait的时间调低一些，比如30s。

Java运行时异常和受检异常区别解析

Java运行时异常和受检异常区别解析Java是一种广泛使用的编程语言，具有强大的异常处理机制。

在Java中，异常分为运行时异常和受检异常两种类型。

这两种异常在语法上有所不同，也有不同的处理方式和使用场景。

本文将深入探讨Java运行时异常和受检异常的区别，并分析它们的特点和应用。

1. 异常的概念和分类在编程中，异常是指程序运行过程中可能发生的错误或异常情况。

Java中的异常分为两种类型：运行时异常和受检异常。

运行时异常是指在程序运行过程中可能出现的错误，但不需要在代码中显式地处理。

这些异常通常是由程序员的错误或逻辑问题引起的，如除零错误、空指针引用等。

运行时异常的典型特点是它们是RuntimeException类或其子类的实例。

受检异常是指在程序运行过程中可能出现的错误，但必须在代码中显式地处理。

这些异常通常是由外部因素引起的，如文件读取错误、网络连接问题等。

受检异常的典型特点是它们是Exception类或其子类的实例，但不是RuntimeException类的子类。

2. 运行时异常的特点和使用场景运行时异常具有以下特点：- 运行时异常不需要在代码中显式地处理，可以选择捕获和处理，也可以不处理。

- 运行时异常通常是由程序员的错误或逻辑问题引起的，如数组越界、类型转换错误等。

- 运行时异常的出现通常意味着代码存在缺陷或错误，需要程序员进行修复。

运行时异常的使用场景包括：- 在开发过程中，如果发现代码中存在逻辑错误或潜在的异常情况，可以使用运行时异常来表示并抛出。

- 运行时异常也可以用于简化代码逻辑，使代码更加简洁和易读。

3. 受检异常的特点和使用场景受检异常具有以下特点：- 受检异常必须在代码中显式地处理，要么通过try-catch语句捕获和处理，要么通过throws关键字声明抛出。

- 受检异常通常是由外部因素引起的，如文件读取错误、网络连接问题等。

- 受检异常的出现通常意味着程序需要采取一些措施来处理外部因素的影响，保证程序的正常运行。

java 什么是异常

java 什么是异常
在程序设计中，错误通常分为两类，即编译错误和运行错误。

编译错误是比较容易发现的，而运行错误无法判断，常常让开发人员感到头疼。

异常是程序运行中一种正常的错误，如果处理异常不当，则影响项目的稳定性。

在Java语言中，异常（Exception）是一个在程序执行期间发生的事件，它中断正在执行程序的正常指令流。

在程序开发过程中，异常产生的范围也比较广，如在编写代码过程、程序调试过程中、项目测试过程中，以及用户运行软件过程中，都会产生一些不同的异常现象。

异常产生的次数（或者数量），正而反应了程序或者项目的质量优劣。

并且，有一些异常便于查找和解决，并不影响项目的运行效率。

但有一些异常可能导致项目部分功能失效或者项目运行效率低，甚至可能导致整个项目失败。

Java的异常处理机制提供一种结构性和控制性的方式来处理程序执行期间发生的事件。

异常处理机制的方式如下：
●在方法中用try…catch语句捕获并处理异常，catch语句可以有多个，用来匹配多个异常。

●对于处理不了的异常或者要转型的异常，在方法的声明处通过throws语句抛出异常，
即由上层的调用方法来处理。

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

try…catch语句用于捕获并处理异常；finally语句用于在任何情况下（除特殊情况外）都必须执行的代码；throw语句用于抛出异常；throws语句用于声明可能会出现的异常。

例如，以下代码是异常处理程序的基本形式：。

java异常--throwable和exception

java异常--throwable和exceptionJava设置了异常，旨在⿎励将⽅法中可能出现的异常告知给使⽤此⽅法的程序员（你和我！）。

当然了，这种⽅法是⽐较优雅的，让我们确切的知道是在哪⾥出了错，并提供了异常捕获。

本篇⽂章主要对Java中的异常进⾏介绍与区分。

先上⼀张类图这是异常的类图。

Throwable是Error和Exception的⽗类，⽤来定义所有可以作为异常被抛出来的类。

Error和Exception区分：Error是编译时错误和系统错误，系统错误在除特殊情况下，都不需要你来关⼼，基本不会出现。

⽽编译时错误，如果你使⽤了编译器，那么编译器会提⽰。

Exception则是可以被抛出的基本类型，我们需要主要关⼼的也是这个类。

Exception⼜分为RunTimeException和其他Exception。

RunTimeException和其他Exception区分：1. 其他Exception，受检查异常。

可以理解为错误，必须要开发者解决以后才能编译通过，解决的⽅法有两种，1：throw到上层，2，try-catch处理。

2. RunTimeException：运⾏时异常，⼜称不受检查异常，不受检查！不受检查！！不受检查重要的事情说三遍，因为不受检查，所以在代码中可能会有RunTimeException时Java编译检查时不会告诉你有这个异常，但是在实际运⾏代码时则会暴露出来，⽐如经典的1/0，空指针等。

如果不处理也会被Java⾃⼰处理。

---------执⾏结果 ---------1运⾏结果是1，为什么呢？主函数调⽤⼦函数并得到结果的过程，好⽐主函数准备⼀个空罐⼦，当⼦函数要返回结果时，先把结果放在罐⼦⾥，然后再将程序逻辑返回到主函数。

所谓返回，就是⼦函数说，我不运⾏了，你主函数继续运⾏吧，这没什么结果可⾔，结果是在说这话之前放进罐⼦⾥的。

2.下⾯的程序代码输出的结果是多少？public class smallT{public static void main(String args[]){smallT t = new smallT();int b = t.get();System.out.println(b);}public int get(){try {return 1;}finally{return 2;}}}返回的结果是2。

Java——异常（Exception）

Java——异常（Exception）A.1. 异常分类所有异常都是由Throwable继承⽽来，但在下⼀层⽴即分解为两个分⽀：Error和Exception Error异常：该层次异常描述了系统运⾏时内部错误和资源耗尽错误。

应⽤程序不该抛出这种类型的对象，如果出现这种错误，除了通告给⽤户，并尽⼒使程序安全推出，再也⽆能为了。

这种情况很少出现。

Exception异常：该层次异常⼜分解为两个分⽀，⼀个派⽣于RuntimeException；另⼀个分⽀包含其他异常。

划分为两个分⽀的规则是：由程序错误导致的异常属于RuntimeException；⽽程序本⾝没问题，但是由于像I/O错误这类问题导致的异常属于其他异常。

Java语⾔规范将派⽣于Error类或RuntimeException类的所有异常称为⾮受(unchecked)查异常，所有其他的异常称为受查(checked)异常。

2. 声明受查异常下⾯四种情况应该抛出异常：1. 调⽤⼀个抛出受查异常的⽅法，例如，FileInputStream构造器。

2. 程序运⾏过程中发现错误，并且利⽤throw语句抛出⼀个受查异常。

3. 程序出现错误。

4. java虚拟机的运⾏时库出现的内部错误。

如果出现前两种情况之⼀，则必须告诉调⽤这个⽅法的程序员有可能抛出异常。

ss对于那些可能被别⼈使⽤的java⽅法，应该根域异常规范，在⽅法的⾸部声明这个⽅法可能抛出的异常。

如果有可能抛出多个异常，应该逗号分开例如：throws FileNotFoundException,EOFException但是不需要声明Error错误，任何程序都有抛出那些异常的潜能，⽽我们对其没有任何控制能⼒。

同样也不该声明从RuntimeException继承的那些⾮受查异常。

警告：如果在⼦类中覆盖了超类的⼀个⽅法，⼦类⽅法中声明的受查异常不能⽐超类⽅法中声明的异常更通⽤（也就是说，⼦类⽅法中可以抛出更特定的异常，或者根本不抛出任何异常）。

Java_异常类（错误和异常,两者的区别介绍）

Java_异常类（错误和异常,两者的区别介绍）在 Java 中，所有的异常都有⼀个共同的祖先 Throwable（可抛出）。

Throwable 指定代码中可⽤异常传播机制通过 Java 应⽤程序传输的任何问题的共性。

Throwable 有两个重要的⼦类：Exception（异常）和 Error（错误），⼆者都是 Java 异常处理的重要⼦类，各⾃都包含⼤量⼦类。

①.Exception（异常）是应⽤程序中可能的可预测、可恢复问题。

⼀般⼤多数异常表⽰中度到轻度的问题。

异常⼀般是在特定环境下产⽣的，通常出现在代码的特定⽅法和操作中。

在 EchoInput 类中，当试图调⽤ readLine ⽅法时，可能出现IOException 异常。

Exception 类有⼀个重要的⼦类 RuntimeException。

RuntimeException 类及其⼦类表⽰“JVM 常⽤操作”引发的错误。

例如，若试图使⽤空值对象引⽤、除数为零或数组越界，则分别引发运⾏时异常（NullPointerException、ArithmeticException）和ArrayIndexOutOfBoundException。

②.Error（错误）表⽰运⾏应⽤程序中较严重问题。

⼤多数错误与代码编写者执⾏的操作⽆关，⽽表⽰代码运⾏时 JVM（Java 虚拟机）出现的问题。

例如，当 JVM 不再有继续执⾏操作所需的内存资源时，将出现 OutOfMemoryError。

检查异常和未检查异常的划分Java中的异常分为两⼤类：1.Checked Exception（⾮Runtime Exception）2.Unchecked Exception（Runtime Exception）运⾏时异常RuntimeException类是Exception类的⼦类，它叫做运⾏时异常，Java中的所有运⾏时异常都会直接或者间接地继承⾃RuntimeException类。

Java里的异常（Exception）详解

Java⾥的异常（Exception）详解作为⼀位初学者, 本屌也没有能⼒对异常谈得很深⼊. 只不过⾥关于Exception的东西实在是很多. 所以这篇⽂章很长就是了..⼀, 什么是java⾥的异常由于java是c\c++ 发展⽽来的, ⾸先我们先看看c语⾔⾥的错误.1.1 c语⾔⾥的错误我们实现1个程序的过程包括, 代码编写, 编译代码成为程序, 执⾏程序..其中⼤部分常见的语法错误都会被编译代码这样部过滤掉. 但是即使通过了编译. 执⾏程序这⼀步可能还是会有错误.原因很多, 例如常见的除数为0, 内存溢出(数组的index超出界限), 或者内存被其他程序修改等.最简单的例⼦:[java]1. #include <stdio.h>2.3. int f(int a, int b){4. return a/b;5. }6.7. int main(){8. int i = f(8,0);9. printf("i is %d\n",i);10. return 0;11. }上⾯的例⼦编译时是⽆错的, 但是⼀旦执⾏就会提⽰吐核错误了.c语⾔⾥对这种执⾏时出现的错误是⽆能为⼒的, ⼀旦出错就会整个程序崩溃, 就不会在继续执⾏下⾯的代码.⽽且很多时候出错信息很少, 让你⽆法判断出错的原因和地⽅, 只能⼀步步⼩⼼debug...所以很多⽤c写的程序有时会出现⾮法关闭的现象.解决⽅法只能是在代码⾥对可能出错的地⽅添加if 判断.例如f()函数⾥可以对b进⾏判断, 如果是0就不执⾏.1.2 java⾥运⾏时出现的错误java⾥编译器对代码的规范性⽐c严格得多. 但是即使如此, 通过编译的java程序有时也很难避免执⾏时出错.例如, 将上⾯的c程序改编成java程序:[java]1. package Exception_kng;2.3. class Exp1{4. public int f(int a, int b){5. return a/b;6. }7. }8.9. public class Expt_1{10. public static void g(){11. Exp1 e = new Exp1();12. int i = e.f(8,0);13. System.out.printf("i is %d\n", i);14. }15. }运⾏时⼀样会出错, 下⾯是出错信息:[java]1. [java] Caused by: ng.ArithmeticException: / by zero2. [java] at Exception_kng.Exp1.f(Expt_1.java:5)3. [java] at Exception_kng.Expt_1.g(Expt_1.java:12)4. [java] at Enter_1.main(Enter_1.java:31)但是可以见到, java告诉你出错的类型: 运算错误(ArithmeticExcetion), 出错信息和出错的类与⽂件⾏数输出, ⽅便你调试. jvm虚拟机是会对错误作出⼀定的处理的.所以可以简单地将java⾥的异常理解成java运⾏时出现的错误, 异常机制就是对这种错误进⾏处理的机制.1.3 java异常的定义实际上, 当java程序执⾏时出现错误时, jvm会把执⾏时出错的信息(例如出错原因, 类型, 位置) 收集,然后打包成为1个对象(object), 程序员可以对这种对象进⾏处理. 这种对象就是所谓的异常.可能出现的异常的代码并不是肯定会出现异常, 取决于执⾏环境和数据.!⼆, java⾥的异常的分类.见下图:Throwable/ \Error Exception/ / \xxxxxx xxxxxx RuntimeException/ \xxxxxx ArithmeticException上图的所有对象都是类.Throwable 代表是可抛出的.Error 代表的是严重错误, 这种错误程序员⽆法进⾏处理, 例如操作系统崩溃, jvm出错, 动态链接库失败等. Error并不是异常, 不是本⽂的重点.Exception 代表的就是异常了. 它下⾯很多派⽣类, 其中它的派⽣类也分两种, ⼀种是RuntimeException(运⾏时异常), 其他的都是⾮运⾏时异常RuntimeException 包括除数为0, 数组下标超界等. 运⾏时异常的派⽣类有很多, 其产⽣频率较⾼. 它的派⽣类可以由程序处理或者抛给(throw) 给jvm处理. 例如上⾯的例⼦就是抛给了jvm处理, jvm把程序中断执⾏, 并把错误信息输出到终端上.⾮RuntimeExcption 这种异常属于Excepion的派⽣类(上⾯红⾊的xxx), 但是不是RuntimeException的派⽣类, 这种异常必须由程序员⼿动处理,否则不通过编译.ArithmeticExcpetion 算术异常, 它是RuntimeException的派⽣类, 所以程序员不⼿动处理也通过编译, 只不过出错时会被jvm处理.三, java⾥对异常的处理java⾥对异常的处理有三种.3.1 程序猿对有可能出现的异常使⽤try catch处理.例如我们将上⾯的例⼦改动⼀下:[java]1. package Exception_kng;2.3. class Exp2{4. public int f(int a, int b){5. int i = 0;6. try{7. i = a/b;8. }9. catch(Exception e){10. System.out.printf("Exception occurs!!\n");11. System.out.println(e.getMessage()); //print the root cause12. System.out.printf("===========================\n");13. e.printStackTrace(); //print the info of function stuck.14. }15.16. return i;17. }18. }19.20. public class Expt_2{21. public static void g(){22. Exp2 ex = new Exp2();23. int i = ex.f(8,0); //call f()24. System.out.printf("i is %d\n", i); //successfully executed25. }26. }在f()函数中对可能出现的异常的代码进⾏try catch处理后, 程序会执⾏catch⾥的代码. ⽽且不会中断整个程序, 继续执⾏try catch后⾯的代码.程序执⾏输出:[java]1. [java] Exception occurs!!2. [java] / by zero3. [java] ===========================4. [java] ng.ArithmeticException: / by zero5. [java] at Exception_kng.Exp2.f(Expt_2.java:7)6. [java] at Exception_kng.Expt_2.g(Expt_2.java:23)7. [java] at Enter_1.main(Enter_1.java:31)8. [java] i is 0注意最终也执⾏了g()函数中的最后⼀条语句, 输出了i的值.也就是说try catch处理后并不会终⽌程序, 令程序即使出现了错误, 也可以对错误进⾏⼀定的处理后继续执⾏. 这就是java异常机制⽐c语⾔安全的地⽅.下⾯会详细讲解 try catch.注:getMessage() ⽅法: Exception类的⽅法之⼀, 返回异常的原因, 上⾯的 / by zero 就是这个⽅法输出的.printStackTrace(): Exception类的⽅法之⼀, 在屏幕输出函数栈信息, 也就是异常出现的地⽅.3.2 函数⾥并不处理异常, 使⽤throw or throws 关键字把可能出现的异常抛给调⽤该函数的上级函数处理.例如我在f()函数中不想处理可能出现的异常, 想把它抛出上级函数处理:下⾯是个例⼦:[java]1. package Exception_kng;2.3. class Exp3{4. public int f(int a, int b){5. if (0 == b){6. throw new ArithmeticException("Shit !!! / by zero!");7.8. }9.10. return a/b;11. }12. }13.14. public class Expt_3{15. public static void g() throws ArithmeticException{16. Exp3 ex = new Exp3();17. int i = 22;18. i = ex.f(8,0); //throw excetpion19. System.out.printf("i is %d\n", i); //failed executed20. System.out.printf("g() is done!!\n"); //failed executed21. }22.23. public static void h(){24. try{25. g();26. }catch(ArithmeticException e){27. System.out.printf("Exception occurs!!\n");28. System.out.println(e.getMessage()); //print the root cause29. System.out.printf("===========================\n");30. e.printStackTrace(); //print the info of function stuck.31. }32.33. System.out.printf("h() is done!!\n"); //successfully executed34. }35. }可以见到f() 加了个条件判断, 如果参数b = 0, 使⽤throw 直接⼿动抛出1个异常. 让调⽤它的函数处理.g()调⽤f()函数, 预见到f()可能有异常, 但是也不想处理, 使⽤throws 关键字告诉调⽤它的函数本函数有可能抛出这种异常. // 注, 这⾥的throws 对程序并没有实质的影响.h()调⽤g(), 简单g()定义的throws, ⽤try catch在本函数进⾏处理.输出:[java]1. [java] Exception occurs!!2. [java] Shit !!! / by zero!3. [java] ===========================4. [java] ng.ArithmeticException: Shit !!! / by zero!5. [java] at Exception_kng.Exp3.f(Expt_3.java:6)6. [java] at Exception_kng.Expt_3.g(Expt_3.java:18)7. [java] at Exception_kng.Expt_3.h(Expt_3.java:25)8. [java] at Enter_1.main(Enter_1.java:31)9. [java] h() is done!!注意这个程序没有执⾏g() 最后的代码.throw 和 throws 后⾯也会详细讲解.3.3 交给jvm虚拟机处理假如上⾯的例⼦h() 也不处理怎么办? 就如1.2 的例⼦, 会抛给jvm处理.但是这种情况只适⽤于RuntimeExecption及其派⽣类.jvm怎么处理呢, 就是中断整个程序, 并把异常信息输出到屏幕上.实际上, 当java程序的1个函数抛出异常时,⾸先会检查当前函数有没有try catch处理, 如果⽆检查上⼀级函数有⽆try..catch处理....这样在函数栈⾥⼀级⼀级向上检查, 如果直⾄main函数都⽆try..catch, 则抛给jvm..项⽬中强烈建议尽量⼿动处理, 不要把异常交给jvm.四,Try catch finally 的处理机制.这⾥开始详解try catch finally了.语法是这样的.try{可能出异常的若⼲⾏代码;}catch(ExceptionName1 e){产⽣ExceptionName 1的处理代码;}catch(ExceptionName2 e){产⽣ExceptionName 2的处理代码;}...finally{⽆论如何, 最终肯定会执⾏的代码}4.1 try catch finally的执⾏路线.下⾯⽤个例⼦来说明:[java]1. try{2. f();3. ff();4. }5. catch(ArithmeticException e){6. g();7. }8. catch(IOException e){9. gg();10. }11. catch(AuthorizedException e){12. ggg();13. }14. finally{15. h();16. }17.18. k();4.1.1 当try⾥⾯的f()抛出了IOException当f()抛出了异常, 那么ff()就不会执⾏了. 程序会尝试捕捉异常.⾸先捕捉ArithmeticException, 捕捉失败.接下来捕捉IOException, 捕捉成功, 执⾏gg();⼀旦捕捉到⼀个异常, 不会再尝试捕捉其他异常, 直接执⾏finally⾥的h();执⾏后⾯的函数k().也就是说路线是:f() -> gg() -> h() -> k()有2点要注意的.1. f()函数极有可能未完整执⾏, 因为它抛出了异常, 抛出异常的语句执⾏失败, 之后的语句放弃执⾏.2. try{} ⾥⾯, f()之后的语句, 例如ff()放弃执⾏.4.1.2 没有任何异常抛出这种情况很简单, 就是try{}⾥⾯的代码被完整执⾏, 因为没有抛出任何异常, 就不会尝试执⾏catch⾥的部分, 直接到finally部分了.路线是:f() -> ff() -> h() -> k()4.2 如何确定要捕捉的异常名字.也许有⼈会问, 我们怎么知道到底会抛出什么异常?下⾯有3个解决⽅案.1.看代码凭经验, 例如看到1段除法的代码, 则有可能抛出算术异常.2.在catch的括号⾥写上Exception e, 毕竟Exception 是所有其他异常的超类, 这⾥涉及多态的知识, ⾄于什么是多态可以看看本⼈的另⼀篇⽂章.3. 观察被调⽤函数的函数定义, 如果有throws后缀, 则可以尝试捕捉throws 后缀抛出的异常4.3 为什么需要finally包括我在内很多⼈会觉得finally语句简直多勾余, 既然是否捕捉到异常都会执⾏, 上⾯那个例⼦⾥的h()为什么不跟下⾯的k() 写在⼀起呢.上⾯的例⼦的确看不出区别.但下⾯两种情况下就体现了finally独特的重要性.4.3.1 抛出了1个异常, 但是没有被任何catch⼦句捕捉成功.例如try⾥⾯抛出了1个A异常, 但是只有后⾯只有捕捉B异常, 和C异常的⼦句.这种情况下, 程序直接执⾏finally{}⾥的⼦句, 然后中断当前函数, 把异常抛给上⼀级函数, 所以当前函数finally后⾯的语句不会被执⾏.例⼦:[java]1. package Exception_kng;2.3. import .*;4. import java.io.*;5.6. class Exp4{7. public int f(int a, int b) throws IOException, BindException{8. return a/b;9. }10. }11.12. public class Expt_4{13. public static void g(){14. Exp4 ex = new Exp4();15. int i = 22;16. try{17. System.out.printf("g() : try!!\n"); //failed18. i = ex.f(8,0); //call f()19. }20. catch(BindException e){21. System.out.printf("g() : BindException!!\n"); //failed22. }23. catch(IOException e){24. System.out.printf("g() : IOException!!\n"); //failed25. }26. finally{27. System.out.printf("g() : finaly!!\n"); //successfully executed28. }29. System.out.printf("g() is done!!\n"); //failed30. }31.32. public static void h(){33. try{34. g();35. }catch(ArithmeticException e){36. System.out.printf("Exception occurs!!\n");37. System.out.println(e.getMessage()); //print the root cause38. System.out.printf("===========================\n");39. e.printStackTrace(); //print the info of function stuck.40. }41.42. System.out.printf("h() is done!!\n"); //successfully executed43. }44. }我所说的情况, 就在上⾯例⼦⾥的g()函数, g()函数⾥尝试捕捉两个异常, 但是抛出了第3个异常(ArithmeticException 算术异常).所以这个异常会中断g()的执⾏, 因为没有被捕捉到, 然后抛给调⽤g()的 h()函数处理, ⽽在h()捕捉到了, 所以h()函数是能完整执⾏的.也就是说g()⾥的[java]1. System.out.printf("g() is done!!\n"); //failed执⾏失败⽽h()⾥的[java]1. System.out.printf("h() is done!!\n"); //successfully executed执⾏成功但是⽆论如何, g()⾥的finally{}部分还是被执⾏了执⾏结果如下:[java]1. [java] g() : try!!2. [java] g() : finaly!!3. [java] Exception occurs!!4. [java] / by zero5. [java] ===========================6. [java] ng.ArithmeticException: / by zero7. [java] at Exception_kng.Exp4.f(Expt_4.java:8)8. [java] at Exception_kng.Expt_4.g(Expt_4.java:18)9. [java] at Exception_kng.Expt_4.h(Expt_4.java:34)10. [java] at Enter_1.main(Enter_1.java:31)11. [java] h() is done!!这种情况是1中编程的低级错误, 在项⽬中是不允许出现.避免⽅法也⼗分简单, 在catch⼦句集的最后增加1个catch(Exception e)就ok, 因为Exception是所有异常的超类, 只要有异常抛出, 则肯定会捕捉到.4.3.2 在catch⼦句内有return⼦句.下⾯例⼦:[java]1. try{2. f();3. ff();4. }5. catch(ArithException e){6. g();7. return j();8. }9. catch(IOException e){10. gg();11. return j();12. }13. catch(AuthorizedException e){14. ggg();15. return j();16. }17. finally{18. h();19. }20.21. k();假如在f()函数抛出了IOExcepion 异常被捕捉到.那么执⾏路线就是f() -> gg() -> j() -> h() -> 上⼀级function也就说, 这种情况下finally⾥的⼦句会在return回上⼀级function前执⾏. ⽽后⾯的k()就被放弃了.4.3.3 finally作⽤⼩结.可以看出, finally⾥的语句, ⽆论如何都会被执⾏.⾄有两种情况除外, ⼀是断电, ⼆是exit函数.在项⽬中, 我们⼀般在finally编写⼀些释放资源的动作, 例如初始化公共变量. 关闭connections, 关闭⽂件等.4.4 try catch finally⾥⼀些要注意的问题.4.4.1 ⽆论如何最多只有1个catch被执⾏这个上⾯提到过了, ⼀旦捕捉到1个异常, 就不会尝试捕捉其他异常.如果try⾥⾯的⼀段代码可能抛出3种异常A B C,⾸先看它先抛出哪个异常, 如果先抛出A, 如果捕捉到A, 那么就执⾏catch(A)⾥的代码. 然后finally.. B和C就没有机会再抛出了.如果捕捉不到A, 就执⾏finally{}⾥的语句后中断当前函数, 抛给上⼀级函数...(应该避免)4.4.2 有可能所有catch都没有被执⾏两种情况, 1就是没有异常抛出, 另⼀种就是抛出了异常但是没有捕捉不到(应该避免)4.4.3 先捕捉⼦类异常, 再捕捉⽗类异常, 否则编译失败加⼊try ⾥⾯尝试捕捉两个异常, 1个是A, 1个是B, 但是A是B的⽗类.这种情况下, 应该把catch(B)写在catch(A)前⾯.原因也很简单, 加⼊把catch(A)写在前⾯, 因为多态的存在, 即使抛出了B异常, 也会被catch(A)捕捉, 后⾯的catch(B)就没有意义了.也就是说如果捕捉Exception这个异常基类, 应该放在最后的catch⾥, 项⽬中也强烈建议这么做, 可以避免上述4.3.1的情况出现.4.4.4 catch与catch之间不能有任何代码.这个没什么好说的. 语法规则4.4.5 finally⾥不能访问catch⾥捕捉的异常对象e每1个异常对象只能由catch它的catch⼦句⾥访问.4.4.6 try⾥⾯的定义变量不能在try外⾯使⽤.跟if类似, 不多说了.4.4.7 try catch finally可以嵌套使⽤.这个也不难理解..五, throw 和throws的机制和⽤法.下⾯开始详讲异常另⼀种处理⽅法throw 和 throws了.注意的是, 这两种⽤法都没有真正的处理异常, 真正处理的异常⽅法只有try catch, 这两种⽅法只是交给上⼀级⽅法处理.就如⼀个组织⾥ , 有1个⼤佬, 1个党主, 1个⼩弟.⼤佬叫党主⼲活, 堂主叫⼩弟⼲活, 然后⼩弟碰上⿇烦了, 但是⼩弟不会处理这个⿇烦, 只能中断⼯作抛给党主处理, 然后堂主发现这个⿇烦只有⼤佬能处理, 然后抛给⼤佬处理..道理是相通的..5.1 throw 的语法与作⽤throws的语法很简单.语法:throw new XException();其中xException必须是Exception的派⽣类.这⾥注意throw 出的是1个异常对象, 所以new不能省略作⽤就是⼿动令程序抛出1个异常对象.5.2 throw 1个 RuntimeException及其派⽣类我们看回上⾯3.2 的例⼦:[java]1. public int f(int a, int b){2. if (0 == b){3. throw new ArithmeticException("Shit !!! / by zero!");4.5. }6.7. return a/b;8. }5.2.1 throw会中断当前函数, 当前函数执⾏失败(不完整)当这个函数的if 判断了b=0时, 就利⽤throws⼿动抛出了1个异常. 这个异常会中断这个函数. 也就是说f()执⾏不完整, 是没有返回值的.5.2.2, 接下来哪个调⽤这个函数就会在调⽤这个函数的语句上收到异常.[java]1. public void g(){2. int i;3. h();4. i = f(); //recevie excepton5. k();6. }例如上没的g()函数, 在调⽤f() 会收到1个异常.这时g()函数有三种选择.1. 不做任何处理这时, g()收到f()⾥抛出的异常就会打断g()执⾏, 也就是说g()⾥⾯的k(); 被放弃了, 然后程序会继续把这个函数抛给调⽤g()函数.然后⼀级⼀级寻求处理, 如果都不处理, 则抛给jvm处理. jvm会中断程序, 输出异常信息. 这个上没提到过了.2. 使⽤try catch处理如果catch成功, 则g()函数能完整执⾏, ⽽且这个异常不会继续向上抛.如果catch失败(尽量避免), 则跟情况1相同.5.3 throw 1个⾮RuntimeException派⽣类的异常将上⾯的例⼦改⼀下:[java]1. public int f(int a, int b){2. if (0 == b){3. throw new IOException("Shit !!! / by zero!");4. }5.6. return a/b;7. }例如, 我不想抛出ArithmeticException, 我想抛出IOExcetpion.注意这⾥, IOException虽然逻辑上是错误的(完全不是IO的问题嘛), 但是在程序中完全可⾏, 因为程序猿可以根据需要控制程序指定抛出任何1个异常.但是这段代码编译失败, 因为IOException 不是 RuntimeException的派⽣类.java规定:5.3.1 如果⼀个⽅法⾥利⽤throw⼿动抛出1个⾮RuntimeException异常, 必须在函数定义声明⾥加上throws 后缀改成这样就正确了:[java]1. public int f(int a, int b) throws IOException{2. if (0 == b){3. throw new IOException("Shit !!! / by zero!");4. }5.6. return a/b;7. }注意在⽅法定义⾥加上了throws⼦句. 告诉调⽤它的函数我可能抛出这个异常.5.3.2 调⽤该⽅法的⽅法则必须处理这个异常例如抄回上⾯的例⼦, g()调⽤f()函数.[java]1. public void g(){2. int i;3. h();4. i = f(); //recevie excepton5. k()6. }但是编译失败.因为f()利⽤throws 声明了会抛出1个⾮runtimeExcetpion. 这时g()必须做出处理.处理⽅法有两种:1. try catch⾃⼰处理:[java]1. public void g(){2. int i = 0;3. h();4. try{5. i = f(); //recevie excepton6. }7. catch(IOException e){8.9. }10. k();11. }需要注意的是, catch⾥⾯要么写上throws对应的异常(这⾥是 IOException), 要么写上这个异常的超类, 否则还是编译失败.2.g()利⽤throws 往上⼀级⽅法抛.[java]1. public void g() throws IOException{2. int i = 0;3. h();4. i = f(); //recevie excepton5. k();6. }这是调⽤g()的函数也要考虑上⾯的这两种处理⽅法了...但是最终上级的⽅法(main ⽅法)还是不处理的话, 就编译失败, 上⾯说过了, ⾮runtimeException⽆法抛给jvm处理.虽然这两种处理⽅法都能通过编译, 但是运⾏效果是完全不同的.第⼀种, g()能完整执⾏.第⼆种, g()被中断, 也就是g()⾥⾯的k(); 执⾏失败.5.4 throws 的语法.throws稍微⽐throw难理解点:语法是:public void f() throws Exception1, Exception2...{}也就是讲, thorws可以加上多个异常, 注意这⾥抛出的不是对象, 不能加上new.⽽且不是告诉别⼈这个函数有可能抛出这么多个异常. ⽽是告诉别⼈, 有可能抛出这些异常的其中⼀种.5.5 throws 的作⽤.如果为f()函数加上throws后续, 则告诉调⽤f()的⽅法, f()函数有可能抛出这些异常的⼀种.如果f()throws 了1个或若⼲个⾮RuntimeException, 则调⽤f()的函数必须处理这些⾮RuntimeException, 如上⾯的g()函数⼀样.如果f() throws的都是RuntimeException, 则调⽤f()的函数可以不处理, 也能通过编译, 但是实际上还是强烈建议处理它们.实际上, 如果1个⽅法f() throws A,B那么它有可能不抛出任何异常.(程序运⾏状态良好)也有能抛出C异常(应该避免, 最好在throws上加上C)5.6 什么时候应该⽤throws5.6.1 ⼀个函数体⾥⾯⼿动throw了1个RumtimeException, 则这个函数的定义必须加上throws⼦句这个是强制, 告诉别⼈这个函数内有炸弹.5.6.2 ⼀个函数内有可能由系统抛出异常.这个是⾮强制的, 但是如果你知道⼀个函数内的代码有可能抛出异常, 最好还是写上throws 后缀⽆论这个异常是否runtimeExcepion.5.7 ⼀般情况下,调⽤1个带有throws⽅法时怎么办个⼈建议, 如果你调⽤1个函数throws A, B, C那么你就在当前函数写上catch(A)catch(B)catch(C)catch(Exception)这样能处理能保证你的函数能完整执⾏, 不会被收到的异常中断.当然如果你允许你的函数可以被中断, 那么就可以在当前函数定义加上throws A, B 继续抛给上⼀级的函数.5.8 重写⽅法时, throws的范围不能⼤于超类的对应⽅法.例如你在⼀个派⽣类重写⼀个⽅法f(), 在超类⾥的f() throws A, B 你重写⽅法时就不throws出 A,,B,C 或者throws A和B的超类.原因也是由于多态的存在.因为1个超类的引⽤可以指向1个派⽣类的对象并调⽤不同的⽅法. 如果派⽣类throws的范围加⼤那么利⽤多态写的代码的try catch就不再适⽤.六, throw和throws⼀些主要区别.⾯试问得多,单独拉出来写了:6.1 throw 写在函数体内, throws写在函数定义语句中.应付⾯试官.6.2 throw 是抛出1个异常对象, throws是有能抛出异常的种类所以throw后⾯的⼀般加上new 和exception名字().⽽throws后⾯不能加上new的6.3 ⼀个⽅法最多只能throw1个异常, 但是可以throws多个种类异常因为⼀旦⼀个函数throw出1个异常, 这个函数就会被中断执⾏, 后⾯的代码被放弃, 如果你尝试在函数内写两个throw, 编译失败.⽽throws 是告诉别⼈这个函数有可能抛出这⼏种异常的⼀种. 但是最多只会抛出⼀种.6.4 如果在⼀个函数体内throw 1个⾮runtimeException, 那么必须在函数定义上加上throws后缀. 但反过来就不是必须的.原因上⾯讲过了.七, ⾃定义异常.我们可以⾃定义异常, 只需要编写1个类, 继承1个异常类就ok例⼦:[java]1. package Exception_kng;2.3. class User_Exception1 extends ArithmeticException{4. public User_Exception1(String Exception_name){5. super(Exception_name);6. }7.8. public void printStackTrace(){ //overwrite9. super.printStackTrace();10. System.out.printf("hey man, i am an user_defined excetpion\n");11. }12. }13.14. class Exp6{15. public int f(int a, int b){16. if (0 == b){17. throw new User_Exception1("Shit !!! / by zero!"); //use User_defined exception18. }19.20. return a/b;21. }22. }23.24. public class Expt_6{25. public static void g() {26. Exp6 ex = new Exp6();27. int i = 22;28. try{29. i = ex.f(8,0); //throw excetpion30. }catch(User_Exception1 e){31. e.printStackTrace();32. }33. System.out.printf("i is %d\n", i);34. System.out.printf("g() is done!!\n");35. }36. }上⾯的类User_Exception1 就是1个⾃定义异常, 并重写了printStackTrace()⽅法.⼋,java异常的优缺点.8.1 c语⾔是如何处理程序错误的.我们要理解异常的优缺点, ⾸先看看没有异常的是如何处理错误的.下⾯是个例⼦:[cpp]1. //openfile2. if (fileOpen() > 0){3. //check the length of the file4. if (gotLengthOfTheFile() > 0){5. //check the memory6. if (gotEnoughMemory() > 0){7. //load file to memory8. if (loadFileToMem() > 0){9. readFile();10. }else{11. errorCode = -5;12. }13.14. }else{15. errorCode = -5;16. }17.18. }else{19. errorCode = -5;20. }21.22. }else{23. errorCode = -5;24. }25.26. //handle error27. case errorCode....28.29. //release Source30. releaseSource();可以见到处理错误有这些特点1. ⼤部分精⼒都在错误处理.2. 需要把各种可能出现的错误全部考虑到, 才能保证程序的稳定性.3. 程序可读性差, 错误处理代码混杂在其他代码中.4. 出错返回信息少, ⼀旦出错难以调试.5. ⼀旦出现了未考虑到的错误, 资源释放代码⽆法执⾏.8.2 java异常机制下是如何编写上述代码的.[java]1. try{2. fileOpen();3. gotLengthOfTheFile();4. gotEnoughMemory();5. loadFileToMem();6. readFile();7. }8. catch(fileOpenFail) { handle1()}9. catch(gotLengthOfTheFileFail) { handle2()}10. catch(gotEnoughMemoryFail) { handle3()}11. catch(loadFileToMemFail) { handle4()}12. catch(readFileFail) { handle4()}13. catch(Exception e) { handle5()} //catch unexpected error14. finally{15. releasSource();16. }8.3 java异常机制的优点:由上⾯的代码可以看出部分优点:1. 业务代码和错误处理代码分离.2. 强制程序猿考虑程序的稳定性.3. 有利于代码调试(异常信息)4. 即使任何异常产⽣, 能保证占⽤的释放(finally)8.4 java异常机制的缺点:1. 异常嵌套难免影响代码可读性2. 并不能令程序逻辑更加清晰.3. 异常并不能解决所有问题。

Java中异常的捕获与处理

Java中异常的捕获与处理⼀、Java异常简介什么是异常？程序运⾏时，发⽣的不被期望的事件，它阻⽌了程序按照程序员的预期正常执⾏，这就是异常。

异常发⽣时，是任程序⾃⽣⾃灭，⽴刻退出终⽌。

在Java中即，Java在编译或运⾏或者运⾏过程中出现的错误。

Java提供了更加优秀的解决办法：异常处理机制。

异常处理机制能让程序在异常发⽣时，按照代码的预先设定的异常处理逻辑，针对性地处理异常，让程序尽最⼤可能恢复正常并继续执⾏，且保持代码的清晰。

Java中的异常可以是函数中的语句执⾏时引发的，也可以是程序员通过throw 语句⼿动抛出的，只要在Java程序中产⽣了异常，就会⽤⼀个对应类型的异常对象来封装异常，JRE就会试图寻找异常处理程序来处理异常。

Java异常机制⽤到的⼏个关键字：try、catch、finally、throw、throws。

try -- ⽤于监听。

将要被监听的代码(可能抛出异常的代码)放在try语句块之内，当try语句块内发⽣异常时，异常就被抛出。

catch -- ⽤于捕获异常。

catch⽤来捕获try语句块中发⽣的异常。

finally -- finally语句块总是会被执⾏。

它主要⽤于回收在try块⾥打开的物⼒资源(如数据库连接、⽹络连接和磁盘⽂件)。

只有finally 块，执⾏完成之后，才会回来执⾏try或者catch块中的return或者throw语句，如果finally中使⽤了return或者throw等终⽌⽅法的语句，则就不会跳回执⾏，直接停⽌。

throw -- ⽤于抛出异常。

throws -- ⽤在⽅法签名中，⽤于声明该⽅法可能抛出的异常。

主⽅法上也可以使⽤throws抛出。

如果在主⽅法上使⽤了throws抛出，就表⽰在主⽅法⾥⾯可以不⽤强制性进⾏异常处理，如果出现了异常，就交给JVM进⾏默认处理，则此时会导致程序中断执⾏。

产⽣异常的原因：⽤户输⼊了⾮法数据。

要打开的⽂件不存在。

java exception 和native exception捕获异常的原理

Java 异常和本地（Native）异常捕获的原理略有不同。

Java 异常：Java 异常是在 Java 虚拟机（JVM）中处理的，其基本原理如下：1.抛出异常：当 Java 代码中发生异常时，会创建一个异常对象，该对象包含异常的类型和相关信息。

然后，这个异常对象被抛出（throw）。

2.异常传播：异常沿着调用堆栈传播，直到找到一个能够处理该异常的地方。

这个地方可以是当前方法内的 catch 块，也可以是调用栈的上层方法。

3.捕获异常：如果异常找到了一个匹配的 catch 块，该块将被执行。

如果没有找到匹配的 catch 块，程序会终止并输出异常信息。

本地异常（Native Exception）：本地异常通常是指在调用本地方法（Native Method）时发生的异常，即在 Java 代码中调用了由本地语言（如C或C++）编写的方法。

在这种情况下，异常处理的流程与 Java 异常有所不同。

1.本地方法调用： Java 代码通过 JNI（Java Native Interface）调用本地方法。

2.本地方法执行：本地方法在本地语言中执行，并且如果在本地方法中发生异常，该异常并不会被 JVM 直接捕获。

3.异常处理：本地异常的处理通常由本地语言的异常处理机制负责。

例如，在 C 或 C++ 中，可能会使用 try-catch 块来处理异常。

因此，Java 代码无法直接捕获本地异常。

为了在 Java 代码中处理本地异常，本地方法通常会提供一些接口，以允许 Java 代码查询本地方法是否发生异常，然后通过 Java 异常机制捕获和处理这些异常。

总体来说，Java 异常是在 JVM 中处理的，而本地异常是在本地方法的执行环境中处理的，两者之间存在一定的隔离。

简述java中的异常处理机制

简述java中的异常处理机制一、概述Java是一种面向对象的编程语言，其异常处理机制是其核心特性之一。

Java的异常处理机制可以让程序员在代码中处理预期和未预期的错误情况，从而提高程序的稳定性和可靠性。

二、异常分类Java中的异常分为两类：受检异常（checked exception）和非受检异常（unchecked exception）。

1. 受检异常受检异常是指在编译时就能够被捕获到的异常，必须要进行处理。

这些异常通常是由于外部环境或用户输入导致的，例如文件不存在、网络连接失败等。

2. 非受检异常非受检异常是指在运行时才能够被捕获到的异常，不需要进行处理。

这些异常通常是由于程序逻辑错误或内存问题导致的，例如空指针引用、数组下标越界等。

三、Exception类及其子类Java中所有的异常都继承自Exception类或RuntimeException类。

其中Exception类包括了所有受检异常，而RuntimeException类包括了所有非受检异常。

1. Exception类Exception类包括了许多子类，如IOException、SQLException等。

这些子类都需要在方法声明中使用throws关键字进行声明或使用try-catch语句进行捕获和处理。

2. RuntimeException类RuntimeException类包括了许多子类，如NullPointerException、ArrayIndexOutOfBoundsException等。

这些子类可以在方法中直接抛出，不需要进行声明或捕获处理。

四、异常处理方式Java中有两种异常处理方式：try-catch语句和throws关键字。

1. try-catch语句try-catch语句用于捕获异常并进行处理。

其基本语法如下：```try {// 可能会抛出异常的代码} catch (ExceptionType e) {// 异常处理代码}```其中，ExceptionType指的是要捕获的异常类型，可以是任何Exception类或其子类。

JAVA-异常处理

JAVA-异常处理1.异常概述1. 异常是运⾏时错误(程序执⾏期间发⽣的事件).2. 异常是从⽅法抛出的,⽅法的调⽤者可以捕获以及处理该异常.3. 异常处理使得程序可以处理运⾏时的错误并且继续通常的执⾏.4. 运⾏时错误: 程序运⾏过程中,若JVM检测出⼀个不可能执⾏的操作.eg.越界下标访问: ArrayIndexOutOfBoundsException5. 异常: JAVA中运⾏时错误会作为异常抛出. 异常为⼀种对象.⼤致模板:try{Code to run;A statement or a method that may throw an exception;More code to run;}catch(type ex){Code to process the exception;}1. 很多库⽅法都会抛出异常,此时throw可省2. ⼀个异常可能是通过try块中的throw语句直接抛出,或者调⽤⼀个可能会抛出异常的⽅法⽽抛出3. 若try块中内容正常执⾏,不会引起异常4. 若try块中内容(⽅法)遇到⼀个异常,其会抛出⼀个异常给它的调⽤者,这个调⽤者的catch处理该异常拋出（throw）异常：⽣成异常对象，并把它提交给运⾏时系统。

捕获（catch）异常：运⾏时系统在⽅法的调⽤栈中查找，直到找到能够处理该类型异常的对象。

2.异常类型Java通过⾯向对象来处理异常，即异常是对象,⽽对象都⽤类来定义。

异常的根类为ng.Throwable异常类的类型：1. 系统错误Error: Java虚拟机抛出,描述内部系统错误.发⽣时:通知⽤户以及尽量稳妥地终⽌程序.2. 异常Exception：描述由程序和外部环境引起的错误.发⽣时:能被程序捕获和处理1. 运⾏时异常(unchecked): RuntimeException类表⽰,程序设计错误。

如 NullPointerException、IndexOutOfBoundsException 等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。

java 异常处理技巧

java 异常处理技巧Java 异常处理技巧1. 异常处理的重要性•异常是程序中常见的错误情况，处理好异常可以提升程序的稳定性和可靠性。

•异常处理可以帮助我们快速定位问题，修复 bug，并改进代码质量。

2. try-catch 块•使用 try-catch 块来捕获和处理异常是一种常见的异常处理技巧。

•在 try 块中编写可能会抛出异常的代码，然后使用 catch 块来处理异常。

•catch 块可以捕获指定类型的异常，并在捕获到异常后执行相应的代码块。

3. 多个 catch 块•在处理异常时，可以使用多个 catch 块来分别捕获不同类型的异常，从而实现更精细的异常处理。

•catch 块按照从上到下的顺序进行匹配，只有第一个匹配的catch 块会执行，其它 catch 块会被忽略。

4. 异常链•在捕获异常时，有时需要同时保留原始异常的信息。

这时可以在catch 块中使用throw关键字重新抛出异常，将原始异常作为新异常的原因。

•如此一来，异常的调用栈就会记录下整个异常传递的过程，方便排查问题。

5. finally 块•finally 块是一种无论是否发生异常都会执行的代码块。

可以在finally 块中释放资源、关闭文件等操作。

•finally 块一般与 try-catch 块一起使用，确保异常处理后的清理工作得到执行。

6. 自定义异常•Java 提供了大量的异常类来满足不同的异常情况。

但是在实际开发中，有时候我们可能需要自定义异常类来满足特定的需求。

•自定义异常类可以继承自 Exception 或 RuntimeException 类，根据实际情况选择合适的父类。

•尽量精细化捕获异常，不要把所有的代码都放在一个 try-catch 块中。

•异常处理应该具有可读性和可维护性。

•在处理异常时，及时记录日志或输出错误信息，方便之后的调试和维护。

•对于不需要处理的异常，可以通过 throws 声明抛出，让调用者来处理。

java 异常处理机制

java 异常处理机制Java 异常处理机制Java 是一门强类型、面向对象、解释性语言，它的异常处理机制使得程序的可靠性大大提升。

当 Java 程序运行时，一旦出现异常，就必须通过异常处理机制来防止程序崩溃，并进行错误的处理。

本文将重点介绍 Java 的异常处理机制。

一、什么是异常处理？异常（exception）是程序运行时出现的非正常情况，如一个数除以零、文件不存在等。

发生异常后，程序通常不再继续进行下去，而是采取相应的措施，比如输出错误信息、关闭文件、弹出对话框等。

异常处理（exception handling）是程序针对异常的一种机制，它可以捕捉异常并进行相应的处理，从而保证程序的正常运行。

Java 异常分类Java 异常可以分为三类：运行时异常、受检异常和错误。

1. 运行时异常（RuntimeException）运行时异常也称为非检查异常，这类异常在程序运行时可能发生，但编译器在编译时并不会检查其是否处理。

主要包括：- 空指针异常（NullPointerException）- 数组下标越界异常（ArrayIndexOutOfBoundsException）- 数字格式异常（NumberFormatException）- 类型转换异常（ClassCastException）- ……2. 受检异常（CheckedException）受检异常需要在代码中显式地处理或声明抛出。

这类异常通常不是由程序错误引起的，而是由外部因素导致，如文件不存在、网络连接断开等。

主要包括：- 文件不存在异常（FileNotFoundException）- IO 异常（IOException）- SQL 异常（SQLException）- ……3. 错误（Error）错误通常指与虚拟机相关的问题，如栈溢出、内存不足等。

错误不需要程序显式地处理，通常也很难处理。

主要包括：- OutOfMemoryError- StackOverflowError- NoClassDefFoundError- ……Java 异常处理机制Java 异常处理机制的核心思想是“捕捉和处理异常”，这通过以下关键字和语句来实现：1. try-catch 语句try-catch 语句用于捕获异常并进行处理。