java所有运行时异常以及错误
Java异常（Exception）处理以及常见异常总结
Java异常（Exception）处理以及常见异常总结⽬录前⾔异常简介异常类型总结前⾔很多事件并⾮总是按照⼈们⾃⼰设计意愿顺利发展的，经常出现这样那样的异常情况。
例如：你计划周末郊游，计划从家⾥出发→到达⽬的→游泳→烧烤→回家。
但天有不测风云，当你准备烧烤时候突然天降⼤⾬，只能终⽌郊游提前回家。
“天降⼤⾬”是⼀种异常情况，你的计划应该考虑到这样的情况，并且应该有处理这种异常的预案。
计算机程序的编写也需要考虑处理这些异常情况。
异常（exception）是在运⾏程序时产⽣的⼀种异常情况，已经成为了衡量⼀门语⾔是否成熟的标准之⼀。
⽬前的主流编程语⾔java也提供了异常处理机制。
异常简介Java中的异常⼜称为例外，是⼀个在程序执⾏期间发⽣的事件，它中断正在执⾏程序的正常指令流。
为了能够及时有效地处理程序中的运⾏错误，必须使⽤异常类，这可以让程序具有极好的容错性且更加健壮。
在 Java 中⼀个异常的产⽣，主要有如下三种原因：1. Java 内部错误发⽣异常，Java 虚拟机产⽣的异常。
2. 编写的程序代码中的错误所产⽣的异常，例如空指针异常、数组越界异常等。
3. 通过 throw 语句⼿动⽣成的异常，⼀般⽤来告知该⽅法的调⽤者⼀些必要信息。
Java 通过⾯向对象的⽅法来处理异常。
在⼀个⽅法的运⾏过程中，如果发⽣了异常，则这个⽅法会产⽣代表该异常的⼀个对象，并把它交给运⾏时的系统，运⾏时系统寻找相应的代码来处理这⼀异常。
我们把⽣成异常对象，并把它提交给运⾏时系统的过程称为拋出（throw）异常。
运⾏时系统在⽅法的调⽤栈中查找，直到找到能够处理该类型异常的对象，这⼀个过程称为捕获（catch）异常。
例 1为了更好地理解什么是异常，下⾯来看⼀段⾮常简单的 Java 程序。
下⾯的⽰例代码实现了允许⽤户输⼊ 1~3 以内的整数，其他情况提⽰输⼊错误。
package io.renren.config;import java.util.Scanner;/*** Created by LiYangYong*/public class TestException {public static void main(String[] args) {System.out.println("请输⼊您的选择：（1~3 之间的整数）");Scanner input = new Scanner(System.in);int num = input.nextInt();switch (num) {case 1:System.out.println("one");break;case 2:System.out.println("two");break;case 3:System.out.println("three");break;default:System.out.println("error");break;}}}正常情况下，⽤户会按照系统的提⽰输⼊ 1~3 之间的数字。
Java常见异常种类
Java常见异常种类------------------------------第⼀种理解----------------------1、什么是异常结构不佳的代码不能运⾏，这是Java的基本理念。
发现错误的理想时机是在编译期。
然⽽，编译器并不能发现所有的错误，余下的问题就需要在程序运⾏时解决。
这就需要错误能通过某种⽅式，把适当的信息传递给特定的接收者处理。
Java中的异常处理的⽬的在于通过使⽤少量的代码来简化⼤型、可靠的程序的⽣成，通过此⽅式让你的应⽤中没有未处理的错误，⽽且它还带来了⼀个明显的好处：降低错误处理代码的复杂度。
异常，根据字⾯理解，有意外之意。
把它置于代码层⾯来理解，即阻⽌了当前⽅法或作⽤域继续执⾏。
在Java中，异常被当做对象来处理，其基类是Throwable。
2、Java中的异常类型 Java从Throwable直接派⽣出Exception和Error。
其中Exception是可以抛出的基本类型，在Java类库、⽅法以及运⾏时故障中都可能抛出Exception型异常。
Exception表⽰可以恢复的异常，是编译器可以捕捉到的；Error表⽰编译时和系统错误，表⽰系统在运⾏期间出现了严重的错误，属于不可恢复的错误，由于这属于JVM层次的严重错误，因此这种错误会导致程序终⽌执⾏。
Exception⼜分为检查异常和运⾏时异常。
异常类的结构层次图如下： 典型的RuntimeException(运⾏时异常)包括NullPointerException, ClassCastException(类型转换异常)，IndexOutOfBoundsException(越界异常), IllegalArgumentException(⾮法参数异常),ArrayStoreException(数组存储异常),AruthmeticException(算术异常),BufferOverflowException(缓冲区溢出异常)等； ⾮RuntimeException(检查异常)包括IOException, SQLException,InterruptedException(中断异常-调⽤线程睡眠时候),NumberFormatException(数字格式化异常)等。
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常见运⾏时错误java常见运⾏时异常1.算术异常类：ArithmeticExecption2.3.空指针异常类：NullPointerException4.5.类型强制转换异常：ClassCastException6.7.数组负下标异常：NegativeArrayException8.9.数组下标越界异常：ArrayIndexOutOfBoundsException10.11.违背安全原则异常：SecturityException12.13.⽂件已结束异常：EOFException14.15.⽂件未找到异常：FileNotFoundException16.17.字符串转换为数字异常：NumberFormatException18.19.20.操作异常：SQLException21.22.23.输⼊输出异常：IOException24.25.26.⽅法未找到异常：NoSuchMethodException27.28.29.1. .lang.nullpointerexception30. 这个异常⼤家肯定都经常遇到，异常的解释是"程序遇上了空指针"，简单地说就是调⽤了未经初始化的对象或者是不存在的对象，这个错误经常出现在创建图⽚，调⽤数组这些操作中，⽐如图⽚未经初始化，或者图⽚创建时的路径错误等等。
对数组操作中出现空指针，很多情况下是⼀些刚开始学习编程的朋友常犯的错误，即把数组的初始化和数组元素的初始化混淆起来了。
数组的初始化是对数组分配需要的空间，⽽初始化后的数组，其中的元素并没有实例化，依然是空的，所以还需要对每个元素都进⾏初始化（如果要调⽤的话）31.32. 2. ng.classnotfoundexception33. 这个异常是很多原本在jb等开发环境中开发的程序员，把 jb下的程序包放在wtk下编译经常出现的问题，异常的解释是"指定的类不存在"，这⾥主要考虑⼀下类的名称和路径是否正确即可，如果是在jb下做的程序包，⼀般都是默认加上package的，所以转到wtk 下后要注意把package的路径加上。
解析Java中所有错误和异常的父类java.lang.Throwable
解析Java中所有错误和异常的⽗类ng.Throwable这篇⽂章主要介绍了Java中所有错误和异常的⽗类ng.Throwable,⽂章中简单地分析了其源码,说明在代码注释中,需要的朋友可以参考下在java语⾔中，错误类的基类是ng.Error，异常类的基类是ng.Exception。
1)相同点：ng.Error和ng.Exception都是ng.Throwable的⼦类，因此ng.Error和ng.Exception⾃⾝及其⼦类都可以作为throw的使⽤对象，如：throw new MyError();和throw new MyException();其中，MyError类是ng.Error的⼦类，MyException类是ng.Exception的⼦类。
2)不同点：ng.Error⾃⾝及其⼦类不需要try-catch语句的⽀持，可在任何时候将返回⽅法，如下⾯的⽅法定义：public String myMethod() {throw new MyError();}其中MyError类是ng.Error类的⼦类。
ng.Exception⾃⾝及其⼦类需要try-catch语句的⽀持，如下的⽅法定义是错误的：public String myMethod() {throw new MyException();}正确的⽅法定义如下：public String myMethod() throws MyException {throw new MyException();}其中MyException类是ng.Exception的⼦类。
JAVA异常是在java程序运⾏的时候遇到⾮正常的情况⽽创建的对象,它封装了异常信息,java异常的根类为ng.Throwable,整个类有两个直接⼦类ng.Error和ng.Exception.Error是程序本⾝⽆法恢复的严重错误.Exception则表⽰可以被程序捕获并处理的异常错误.JVM⽤⽅法调⽤栈来跟踪每个线程中⼀系列的⽅法调⽤过程,该栈保存了每个调⽤⽅法的本地信息.对于独⽴的JAVA程序,可以⼀直到该程序的main⽅法.当⼀个新⽅法被调⽤的时候,JVM把描述该⽅法的栈结构置⼊栈顶,位于栈顶的⽅法为正确执⾏的⽅法.当⼀个JAVA⽅法正常执⾏完毕,JVM回从调⽤栈中弹处该⽅法的栈结构,然后继续处理前⼀个⽅法.如果java⽅法在执⾏代码的过程中抛出异常,JVM必须找到能捕获异常的catch块代码.它⾸先查看当前⽅法是否存在这样的catch代码块,如果存在就执⾏该 catch代码块,否则JVM回调⽤栈中弹处该⽅法的栈结构,继续到前⼀个⽅法中查找合适的catch代码块.最后如果JVM向上追到了main()⽅法,也就是⼀直把异常抛给了main()⽅法,仍然没有找到该异常处理的代码块,该线程就会异常终⽌,如果该线程是主线程,应⽤程序也随之终⽌,此时 JVM将把异常直接抛给⽤户,在⽤户终端上会看到原始的异常信息.ng.throwable源代码解析package ng;import java.io.*;/**** Throwable是所有Error和Exceptiong的⽗类* 注意它有四个构造函数:* Throwable()* Throwable(String message)* Throwable(Throwable cause)* Throwable(String message, Throwable cause)**/public class Throwable implements Serializable {private static final long serialVersionUID = -3042686055658047285L;/*** Native code saves some indication of the stack backtrace in this slot.* Native code saves some indication of the stack backtrace in this slot. */private transient Object backtrace;/*** 描述此异常的信息*/private String detailMessage;/*** 表⽰当前异常由那个Throwable引起* 如果为null表⽰此异常不是由其他Throwable引起的* 如果此对象与⾃⼰相同,表明此异常的起因对象还没有被初始化*/private Throwable cause = this;/*** 描述异常轨迹的数组*/private StackTraceElement[] stackTrace;/*** 构造函数,起因对象没有被初始化可以在以后使⽤initCause进⾏初始化 * fillInStackTrace可以⽤来初始化它的异常轨迹的数组*/public Throwable() {fillInStackTrace();}/*** 构造函数*/public Throwable(String message) {//填充异常轨迹数组fillInStackTrace();//初始化异常描述信息detailMessage = message;}/*** 构造函数,cause表⽰起因对象*/public Throwable(String message, Throwable cause) {fillInStackTrace();detailMessage = message;this.cause = cause;}/*** 构造函数*/public Throwable(Throwable cause) {fillInStackTrace();detailMessage = (cause==null ? null : cause.toString());this.cause = cause;}/*** 获取详细信息*/public String getMessage() {return detailMessage;}/*** 获取详细信息* 获取详细信息*/public String getLocalizedMessage() {return getMessage();}/*** 获取起因对象*/public Throwable getCause() {return (cause==this ? null : cause);}/*** 初始化起因对象,这个⽅法只能在未被初始化的情况下调⽤⼀次*/public synchronized Throwable initCause(Throwable cause) {//如果不是未初始化状态则抛出异常if (this.cause != this)throw new IllegalStateException("Can't overwrite cause");//要设置的起因对象与⾃⾝相等则抛出异常if (cause == this)throw new IllegalArgumentException("Self-causation not permitted");//设置起因对象this.cause = cause;//返回设置的起因的对象return this;}/*** 字符串表⽰形式*/public String toString() {String s = getClass().getName();String message = getLocalizedMessage();return (message != null) ? (s + ": " + message) : s;}/*** 打印出错误轨迹*/public void printStackTrace() {printStackTrace(System.err);}/*** 打印出错误轨迹*/public void printStackTrace(PrintStream s) {synchronized (s) {//调⽤当前对象的toString⽅法s.println(this);//获取异常轨迹数组StackTraceElement[] trace = getOurStackTrace();//打印出每个元素的字符串表⽰for (int i=0; i < trace.length; i++)s.println("\tat " + trace[i]);//获取起因对象Throwable ourCause = getCause();//递归的打印出起因对象的信息if (ourCause != null)if (ourCause != null)ourCause.printStackTraceAsCause(s, trace);}}/*** 打印起因对象的信息* @param s 打印的流* @param causedTrace 有此对象引起的异常的异常轨迹*/private void printStackTraceAsCause(PrintStream s,StackTraceElement[] causedTrace){//获得当前的异常轨迹StackTraceElement[] trace = getOurStackTrace();//m为当前异常轨迹数组的最后⼀个元素位置,//n为当前对象引起的异常的异常轨迹数组的最后⼀个元素int m = trace.length-1, n = causedTrace.length-1;//分别从两个数组的后⾯做循环,如果相等则⼀直循环,直到不等或数组到头 while (m >= 0 && n >=0 && trace[m].equals(causedTrace[n])) {m--; n--;}//相同的个数int framesInCommon = trace.length - 1 - m;//打印出不同的错误轨迹s.println("Caused by: " + this);for (int i=0; i <= m; i++)s.println("\tat " + trace[i]);//如果有相同的则打印出相同的个数if (framesInCommon != 0)s.println("\t... " + framesInCommon + " more");//获得此对象的起因对象,并递归打印出信息Throwable ourCause = getCause();if (ourCause != null)ourCause.printStackTraceAsCause(s, trace);}/*** 打印出错误轨迹*/public void printStackTrace(PrintWriter s) {synchronized (s) {s.println(this);StackTraceElement[] trace = getOurStackTrace();for (int i=0; i < trace.length; i++)s.println("\tat " + trace[i]);Throwable ourCause = getCause();if (ourCause != null)ourCause.printStackTraceAsCause(s, trace);}}/*** 打印起因对象的信息*/private void printStackTraceAsCause(PrintWriter s,StackTraceElement[] causedTrace){// assert Thread.holdsLock(s);// Compute number of frames in common between this and causedStackTraceElement[] trace = getOurStackTrace();StackTraceElement[] trace = getOurStackTrace();int m = trace.length-1, n = causedTrace.length-1;while (m >= 0 && n >=0 && trace[m].equals(causedTrace[n])) {m--; n--;}int framesInCommon = trace.length - 1 - m;s.println("Caused by: " + this);for (int i=0; i <= m; i++)s.println("\tat " + trace[i]);if (framesInCommon != 0)s.println("\t... " + framesInCommon + " more");// Recurse if we have a causeThrowable ourCause = getCause();if (ourCause != null)ourCause.printStackTraceAsCause(s, trace);}/*** 填充异常轨迹*/public synchronized native Throwable fillInStackTrace();/*** 返回当前的异常轨迹的拷贝*/public StackTraceElement[] getStackTrace() {return (StackTraceElement[]) getOurStackTrace().clone();}/*** 获取当前的异常轨迹*/private synchronized StackTraceElement[] getOurStackTrace() { //如果第⼀次调⽤此⽅法则初始化异常轨迹数组if (stackTrace == null) {//获得异常轨迹深度int depth = getStackTraceDepth();//创建新的异常轨迹数组,并填充它stackTrace = new StackTraceElement[depth];for (int i=0; i < depth; i++)stackTrace[i] = getStackTraceElement(i);//获取指定位标的异常轨迹 }return stackTrace;}/*** 设置异常轨迹*/public void setStackTrace(StackTraceElement[] stackTrace) {//拷贝设置参数StackTraceElement[] defensiveCopy =(StackTraceElement[]) stackTrace.clone();//如果设置参数有空元素则抛出异常for (int i = 0; i < defensiveCopy.length; i++)if (defensiveCopy[i] == null)throw new NullPointerException("stackTrace[" + i + "]");//设置当前对象的异常轨迹this.stackTrace = defensiveCopy;}}/*** 异常轨迹的深度,0表⽰⽆法获得*/private native int getStackTraceDepth();/*** 获取指定位标的异常轨迹*/private native StackTraceElement getStackTraceElement(int index);private synchronized void writeObject(java.io.ObjectOutputStream s)throws IOException{getOurStackTrace();s.defaultWriteObject();}}以下讲述的是平时遇到的，⽐较常见的具体异常情况，跟上⾯有部分重复：Throwable是所有异常的根，ng.ThrowableError是错误，ng.ErrorException是异常，ng.ExceptionThrowable：有两个重要的⼦类：Exception（异常）和 Error（错误），⼆者都是 Java 异常处理的重要⼦类，各⾃都包含⼤量⼦类。
java所有运行时异常以及错误
算术异常类：Arithm eticE xecpt ion空指针异常类：NullPo inter Excep tion类型强制转换异常：ClassC astEx cepti on数组负下标异常：Negati veArr ayExc eptio n数组下标越界异常：ArrayI ndexO utOfB ounds Excep tion违背安全原则异常：Sectur ityEx cepti on文件已结束异常：EOFExc eptio n文件未找到异常：FileNo tFoun dExce ption字符串转换为数字异常：Number Forma tExce ption操作数据库异常：SQLExc eptio n输入输出异常：IOExce ption方法未找到异常：NoSuch Metho dExce ptionng.Abstra ctMet hodEr ror抽象方法错误。
当应用试图调用抽象方法时抛出。
ng.Assert ionEr ror断言错。
用来指示一个断言失败的情况。
ng.ClassC ircul arity Error类循环依赖错误。
在初始化一个类时，若检测到类之间循环依赖则抛出该异常。
ng.ClassF ormat Error类格式错误。
当Java虚拟机试图从一个文件中读取Jav a类，而检测到该文件的内容不符合类的有效格式时抛出。
ng.Error错误。
是所有错误的基类，用于标识严重的程序运行问题。
这些问题通常描述一些不应被应用程序捕获的反常情况。
ng.Except ionIn Initi alize rErro r初始化程序错误。
当执行一个类的静态初始化程序的过程中，发生了异常时抛出。
runtimeexception 种类
RuntimeException是Java语言中的一种重要异常类型，它代表在运行时可能会出现的异常情况。
RuntimeException是Java运行时环境（JRE）中的异常类的超类，这些异常通常是由于程序本身的错误而引发的，而不是由于外部环境（例如操作系统或硬件）的问题。
RuntimeException异常类本身并不是一个具体的异常，而是代表了一个异常类别。
在Java中，RuntimeException异常类别中的具体异常类有很多，例如NullPointerException、ClassCastException、IllegalArgumentException、ArithmeticException等。
这些异常类具有不同的含义和表现形式，例如：
* NullPointerException：当程序试图在需要对象的地方使用null 时抛出，表示出现了空指针异常。
* ClassCastException：当试图将一个对象强制转换为不是实例的子类时抛出，表示类型强制转换异常。
* IllegalArgumentException：当向方法传递了一个不合法或不正确的参数时抛出，表示参数异常。
* ArithmeticException：当进行算术运算时发生异常，例如整数“除以零”时抛出，表示算术异常。
需要注意的是，虽然RuntimeException异常类在Java中是未检
查的异常（即编译器不会强制要求程序员处理这些异常），但这些异常仍然需要被适当地处理，以避免对程序造成不可预知的影响。
Java运行时异常和非运行时异常
Java运⾏时异常和⾮运⾏时异常1.异常机制Java把异常当做对象来处理，并定义⼀个基类ng.Throwable作为所有异常的超类。
Java中的异常分为两⼤类：错误Error和异常Exception，Java异常体系结构如下图所⽰：2.ThrowableThrowable类是所有异常或错误的超类，它有两个⼦类：Error和Exception，分别表⽰错误和异常。
其中异常Exception分为运⾏时异常(RuntimeException)和⾮运⾏时异常，也称之为不检查异常(Unchecked Exception)和检查异常(Checked Exception)。
3.Error⼀般是指java虚拟机相关的问题，如系统崩溃、虚拟机出错误、动态链接失败等，这种错误⽆法恢复或不可能捕获，将导致应⽤程序中断，通常应⽤程序⽆法处理这些错误，因此应⽤程序不应该捕获Error对象，也⽆须在其throws⼦句中声明该⽅法抛出任何Error或其⼦类。
4.可查异常和不可查异常通常，Java的异常(包括Exception和Error)分为可查的异常（checked exceptions）和不可查的异常（unchecked exceptions）。
可查异常（编译器要求必须处置的异常）：正确的程序在运⾏中，很容易出现的、情理可容的异常状况。
可查异常虽然是异常状况，但在⼀定程度上它的发⽣是可以预计的，⽽且⼀旦发⽣这种异常状况，就必须采取某种⽅式进⾏处理。
除了RuntimeException及其⼦类以外，其他的Exception类及其⼦类都属于可查异常。
这种异常的特点是Java编译器会检查它，也就是说，当程序中可能出现这类异常，要么⽤try-catch语句捕获它，要么⽤throws⼦句声明抛出它，否则编译不会通过。
不可查异常(编译器不要求强制处置的异常):包括运⾏时异常（RuntimeException与其⼦类）和错误（Error）。
运行时异常和非运行时异常的理解
运行时异常和非运行时异常的理解
运行时异常和非运行时异常都是Java中的异常类型，但它们在发生的时间和处理方式上有所不同。
运行时异常是指在程序运行过程中发生的异常，通常是由于程序员的错误造成的，例如空指针异常、数组下标越界异常等。
这些异常在程序运行时可能会被抛出，如果没有进行处理，程序就会中断，导致程序的崩溃。
非运行时异常是指在程序编译时就可以发现的异常，也称为编译时异常。
这些异常通常是由于外部环境或资源不足等原因引起的，例如文件读取异常、网络连接异常等。
这些异常在程序编译时就需要进行处理，如果没有处理，程序将无法通过编译。
处理运行时异常的方式是使用try-catch语句捕获异常，然后进行相关处理，如重新尝试执行代码或输出错误信息。
处理非运行时异常的方式也是使用try-catch语句捕获异常，但需要在代码中明确地声明可能会抛出的异常，并在方法签名中进行声明。
总之，了解和正确处理异常是编写高质量Java程序的重要组成部分。
对于运行时异常和非运行时异常的理解和处理，可以帮助程序员更好地调试程序，提高代码质量和可维护性。
- 1 -。
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中的报错机制
java中的报错机制异常：Exception，程序运⾏过程中因为⼀些原因，使得程序⽆法运⾏下去注意：在程序能够运⾏起来的情况，不是程序编译通不过举例：读⽂件，点击⼀个按钮，⽂件不存在；访问数据库服务器，数据库服务器停电了（1）异常的出现由于运⾏中遇到预想不到的情况（2）异常的性质1）出现异常，程序全部终⽌，不运⾏后⾯的代码2）当出现异常时，系统会将异常封装在⼀个类的对象中，通知系统终⽌（抛出异常）。
如果任由软件出现异常，软件将⾮常不稳定，质量很低（3）异常如何处理？1）⽤try将可能出现异常的代码包围起来2）将出现异常之后的处理代码⽤catch包围起来，放在try的后⾯原理：系统运⾏try中的代码，如果没有异常，将不会运⾏catch中的代码；如果出现异常，将略过try中剩余的代码，转⽽执⾏catch中的代码，catch中代码执⾏完毕之后，再执⾏软件剩余的代码注意：⼀个try后⾯可以接1个或多个catch，catch中的异常类型不同，捕捉不同的异常，catch中如果写catch(Exception e)则捕捉所有异常还有⼀个finally，⽤在catch后⾯，可⽤可不⽤，最多只能⽤⼀个finally中，保存不管是否出现异常，⼀定要执⾏的代码举例：打开⼀个⽂件，读⽂件，关闭⽂件连接在读⽂件过程中不管是否出现异常，关闭⽂件的⼯作⼀定要做finally并不是可有可⽆的！finally中的代码，只要整个软件还在运⾏，不管当前作⽤域是否结束，都会执⾏⼀次。
如果不将代码放在finally中，就不会有这样的效果。
异常的概念异常的出现异常的处理try-catch-finallytry只有1个，catch1个以上，finally最多1个------异常的其他应⽤（1）通过异常改变程序⾏为举例：输⼊⼀个数，显⽰该数平⽅。
但是，如果输⼊格式不是数字，将反复出现输⼊框，直到输⼊正确为⽌。
（2）通过⾃定义异常来封装程序错误信息举例：编写⼀个函数，输⼊⼀个年龄，0-100之间，返回年龄给主函数。
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中常见的几种RuntimeException,大约有如下几种：1.NullPointerException -空指针引用异常2.ClassCastException -类型强制转换异常。
3.IllegalArgumentException -传递非法参数异常。
4.ArithmeticException -算术运算异常5.ArrayStoreException -向数组中存放与声明类型不兼容对象异常6.IndexOutOfBoundsException -下标越界异常7.NegativeArraySizeException -创建一个大小为负数的数组错误异常8.NumberFormatException -数字格式异常9.SecurityException -安全异常10.UnsupportedOperationException -不支持的操作异常如下：RuntimeException是开发中最容易遇到的，下面列举一下常见的RuntimeException：1、NullPointerException：见的最多了，其实很简单，一般都是在null对象上调用方法了。
String s=null;booleaneq=s.equals(""); // NullPointerException这里你看的非常明白了，为什么一到程序中就晕呢？public intgetNumber(String str){if(str.equals("A")) return 1;else if(str.equals("B")) return 2;}这个方法就有可能抛出NullPointerException,我建议你主动抛出异常，因为代码一多，你可能又晕了。
public intgetNumber(String str){if(str==null) throw new NullPointerException("参数不能为空");//你是否觉得明白多了if(str.equals("A")) return 1;else if(str.equals("B")) return 2;}2、NumberFormatException：继承IllegalArgumentException，字符串转换为数字时出现。
java运行时异常
ng.OutOfMemoryError: PermGen space 内存溢出未解决？？？？？？？？？？？？？不明白为什么，什么错误导致的javax.servlet.ServletException:Request[/yhb] does not contain handler parameter named ‘method’. This may be caused by whitespace in the label text.解决:form表单中缺少提交方法method=post/getng.ClassCastException: [ng.Object;atcom.carry.service.impl.YhbManagerImpl.loginCheck(YhbManagerImpl.java: 44)javax.servlet.ServletException:Could not open Hibernate Session for transaction; nested exception is org.hibernate.exception.GenericJDBCException: Cannotopen connectionng.NoClassDefFoundError:org/eclipse/jdt/internal/compiler/ast/ArrayTypeReference解决办法：内存溢出，重新启动服务器METHOD传参数方法找不到，ACTION中，方法的四个参数顺序不能颠倒tsList(ActionMapping mapping,ActionForm form,HttpServletRequest request,HttpServletResponse response)throws Exception异常：不能连接数据库（解决：数据库连接不上，连接异常，1，检查网络连接，2，检查是否有连接驱动，）Could not obtain connection metadatamons.dbcp.SQLNestedException: Cannot create PoolableConnectionFactory(Io异常: Connection refused(DESCRIPTION=(TMP=)(VSNNUM=150999297)(ERR=12505)(ERROR_STACK=( ERROR=(CODE=12505)(EMFI=4)))))连接拒绝[SettingsFactory] Could not obtain connection metadatamons.dbcp.SQLNestedException: Cannot create PoolableConnectionFactory(Io异常: The Network Adapter could not establish the connection)网络适配器不能建立连接，ORACLE数据库服务器没有打开java.io.IOException: tmpFile.renameTo(classFile) failed解决：JSP文件中有不能运行的JAVA代码！Unable to find a value for “id”in object of class “ng.String”using operator “.”解决：<c:forEach var=”fun”items=”${listFun}”><c:forEach> 中的items=”${listFun}”错写为items=”listFun”Illegal use of <when>-style tag without <choose> as its direct parent”${map.yuanYouPur=’yuanYouPur’}”contains invalid expression(s): javax.servlet.jsp.el.ELException: Encountered “=”, expectedone of [”]”, “.”, “>”, “gt”, “<”, “lt”, “==”, “eq”, “<=”, “le”, “>=”, “ge”, “!=”, “ne”, “[”, “+”, “-“, “*”, “/”, “div”, “%”,“mod”, “and”, “&&”, “or”, “||”, “?”]解决：JSTL语言表达使用错误！The “.”operator was supplied with an index value of type “ng.String” to be applied to a List or array, but that valuecannot be converted to an integer.解决：JSP页面中，用‘ ${} ’输出获得的对象的属性，使用错误，例如返回LIST数组，其中存的对象是OBJ（页面中可以定义变量obj代表一个OBJ），取OBJ的属性AGE，NAME, 应该是${obj.age} ${}即可获得OBJ的AGE和NAME属性值,检查在使用${}的地方${obj.age} ${}是否正确，异常不能正常打开JSP文件！（2007.08.31） enough of enjoyment and comfort Unable to create this part due to an internal error. Reason for the failure: Widget is disposedorg.eclipse.swt.SWTException: Widget is disposed解决方法：1到window－preference－general－editors－file associations下看看你的*.html默认打开方式是什么。
java常见编译错误信息及说明
Java编译错误信息及说明1、java:33: 不是语句解释：程序中出现了没有任何意义的字符（串），可能是无意中打出了没有任何意义的字符；2、java:34: 需要';'解释：某条语句没有以分号结束；3、java:36: 缺少返回语句解释：带返回值的函数缺少return语句；4、java:33: 不兼容的类型解释：运算符两边的数据类型不一致或者不能做隐式转换；5、java:36: 无法访问的语句解释：此语句永远不可能被执行，可能是此语句之前存在类似于while（true）的语句，导致此语句永远不可能被执行；6、java:34: 非法的表达式开始解释：有不符合语法规范的表达式出现；7、java:34: 找不到符号解释：使用了没有定义或没有引入的变量；8、java:33: 非法字符：\65307解释：在中文输入状态下输入了一些标点符号；9、java:18: 不可转换的类型解释：运算符两边的数据类型不一致或者不能做隐式转换；10、java:19: "else" 不带有"if"解释：编译器找到else语句但是没有找到与之对应的if语句，可能是由于大括号没有成对出现；11、java:12: 可能损失精度解释：把高精确度类型的数据赋值给低精确度类型的变量；12、java:17: 需要')'解释：括号没有成对出现；13、java:8: 可能尚未初始化变量s解释：局部变量s没有赋初值；14、java:7: 不可比较的类型：int 和Boolean解释：运算符两边操作数的数据类型不符合运算符的使用规范；15、java:6: 已在isLeap(int) 中定义year解释：变量year被重复定义；16、java:21: 字符字面值的行结尾不合法解释：程序语句的结尾不是java规定的结束符号，而是其他的符号；17、java:9: 需要<标识符>解释：可能是由于用户指定了数据类型，但未指定该类型的变量名；18、java:8: 无法从静态上下文中引用非静态变量this解释：在静态方法中使用了非静态变量this；19、java:12: 在switch 或loop 外部中断解释：在非循环语句或非switch语句中使用了中断循环功能的语句break；20、java:21: 对于结果类型为void 的方法，无法返回值解释：空返回值方法中出现了return语句；21、java:12: 需要数组，但找到int解释：在应该出现数组的地方没有找到数组类型的变量，而是找到int类型的变量；22、java:13: 无法将Node 中的setData(int) 应用于()解释：一般情况下是方法调用时缺少了参数；23、java:5: 缺少数组维数解释：数组的定义过程中没有指定数组的维数；24、进行语法解析时已到达文件结尾解释：一般情况是缺少{}造成的；25、需要为class、interface 或enum解释：一般情况下是多了{}造成的；26、无法为最终变量length 指定值解释：Length为final类型的变量，值不能修改。
java程序错误类型及异常处理
java程序错误类型及异常处理⼀、程序的错误类型在程序设计中，⽆论规模是⼤是⼩，错误总是难免的。
程序的设计很少有能够⼀次完成，没有错误的（不是指HelloWorld这样的程序，⽽是要实现⼀定的功能，具备⼀定实⽤价值的程序），在编程的过程中由于种种原因，总会出现这样或那样的错误，这些程序的错误就是我们常说的“Bug”，⽽检测并修正这些错误的⽅法就是“Debug”（调试）。
基本上所有的集成开发环境都提供了强⼤的和程序调试功能，在程序进⾏编译，连接，运⾏时，会对程序中错误进⾏诊断。
程序的错误可以抽象分为三类：语法错误、运⾏错误和逻辑错误。
1、语法错误是指由于编程中输⼊不符合语法规则⽽产⽣的。
程序编译就通不过，程序不能运⾏起来。
此类错误最简单，调试起来⽐较容易例如：表达式不完整、缺少必要的标点符号、关键字输⼊错误、数据类型不匹配、循环语句或选择语句的关键字不匹配等。
通常，编译器对程序进⾏编译的过程中，会把检测到的语法错误以提⽰的⽅式列举出来，⼜称为编译错误。
语法错误的调试，则可以由集成开发环境提供的调试功能来实现，在程序进⾏编译时，编译器会对程序中的语法错误进⾏诊断。
编译诊断的语法错误分为3中：致命错误、错误和警告。
（1）致命错误：这个错误⼤多是编译程序内部发⽣的错误，发⽣这类错误时，编译被迫中⽌，只能重新启动编译程序，但是这类错误很少发⽣，为了安全，编译前最好还是先保存程序。
（2）错误：这个错误通常是在编译时，语法不当所引起的。
例如：括号不匹配，变量未声明等。
产⽣这类错误时，编译程序会出现报错提⽰，我们根据提⽰对源程序进⾏修改即可。
这类错误是出现最多的。
（3）警告：是指被编译程序怀疑有错，但是不确定，有时可强⾏通过。
例如：没有加void声明的主函数没有返回值，double数据被转换为float类型等。
这些警告中有些会导致错误，有些可以通过。
常规解决⽅法：此类错误⼀般程序编译系统会⾃动提⽰相应的错误地点和错误原因，⽐如哪⼀⾏代码少了个括号等诸如此类的提⽰，常见的错误，看懂直接改正即可，如果是看不懂原因，可以将错误提⽰信息输⼊搜索引擎查找⼀下，⼀般都能找到具体的解决办法。
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 Exception：1、Error2、Runtime Exception 运⾏时异常3、Exception4、throw ⽤户⾃定义异常异常类分两⼤类型：Error类代表了编译和系统的错误，不允许捕获；Exception类代表了标准Java库⽅法所激发的异常。
Exception类还包含运⾏异常类Runtime_Exception和⾮运⾏异常类Non_RuntimeException这两个直接的⼦类。
运⾏异常类对应于编译错误，它是指Java程序在运⾏时产⽣的由解释器引发的各种异常。
运⾏异常可能出现在任何地⽅，且出现频率很⾼，因此为了避免巨⼤的系统资源开销，编译器不对异常进⾏检查。
所以Java语⾔中的运⾏异常不⼀定被捕获。
出现运⾏错误往往表⽰代码有错误，如：算数异常（如被0除）、下标异常（如数组越界）等。
⾮运⾏异常时Non_RuntimeException类及其⼦类的实例，⼜称为可检测异常。
Java编译器利⽤分析⽅法或构造⽅法中可能产⽣的结果来检测Java程序中是否含有检测异常的处理程序，对于每个可能的可检测异常，⽅法或构造⽅法的throws⼦句必须列出该异常对应的类。
在Java 的标准包ng java.util 和 中定义的异常都是⾮运⾏异常。
算术异常类：ArithmeticExecption空指针异常类：NullPointerException类型强制转换异常：ClassCastException数组负下标异常：NegativeArrayException数组下标越界异常：ArrayIndexOutOfBoundsException违背安全原则异常：SecturityException⽂件已结束异常：EOFException⽂件未找到异常：FileNotFoundException字符串转换为数字异常：NumberFormatException操作数据库异常：SQLException输⼊输出异常：IOException⽅法未找到异常：NoSuchMethodExceptionng.AbstractMethodError抽象⽅法错误。
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 语句用于捕获异常并进行处理。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
算术异常类：ArithmeticExecption空指针异常类：NullPointerException类型强制转换异常：ClassCastException数组负下标异常：NegativeArrayException数组下标越界异常：ArrayIndexOutOfBoundsException违背安全原则异常：SecturityException文件已结束异常：EOFException文件未找到异常：FileNotFoundException字符串转换为数字异常：NumberFormatException操作数据库异常：SQLException输入输出异常：IOException方法未找到异常：NoSuchMethodExceptionng.AbstractMethodError抽象方法错误。
当应用试图调用抽象方法时抛出。
ng.AssertionError断言错。
用来指示一个断言失败的情况。
ng.ClassCircularityError类循环依赖错误。
在初始化一个类时，若检测到类之间循环依赖则抛出该异常。
ng.ClassFormatError类格式错误。
当Java虚拟机试图从一个文件中读取Java类，而检测到该文件的内容不符合类的有效格式时抛出。
ng.Error错误。
是所有错误的基类，用于标识严重的程序运行问题。
这些问题通常描述一些不应被应用程序捕获的反常情况。
ng.ExceptionInInitializerError初始化程序错误。
当执行一个类的静态初始化程序的过程中，发生了异常时抛出。
静态初始化程序是指直接包含于类中的static语句段。
ng.IllegalAccessError违法访问错误。
当一个应用试图访问、修改某个类的域（Field）或者调用其方法，但是又违反域或方法的可见性声明，则抛出该异常。
ng.IncompatibleClassChangeError不兼容的类变化错误。
当正在执行的方法所依赖的类定义发生了不兼容的改变时，抛出该异常。
一般在修改了应用中的某些类的声明定义而没有对整个应用重新编译而直接运行的情况下，容易引发该错误。
ng.InstantiationError实例化错误。
当一个应用试图通过Java的new操作符构造一个抽象类或者接口时抛出该异常.ng.InternalError内部错误。
用于指示Java虚拟机发生了内部错误。
ng.LinkageError链接错误。
该错误及其所有子类指示某个类依赖于另外一些类，在该类编译之后，被依赖的类改变了其类定义而没有重新编译所有的类，进而引发错误的情况。
ng.NoClassDefFoundError未找到类定义错误。
当Java虚拟机或者类装载器试图实例化某个类，而找不到该类的定义时抛出该错误。
ng.NoSuchFieldError域不存在错误。
当应用试图访问或者修改某类的某个域，而该类的定义中没有该域的定义时抛出该错误。
ng.NoSuchMethodError方法不存在错误。
当应用试图调用某类的某个方法，而该类的定义中没有该方法的定义时抛出该错误。
ng.OutOfMemoryError内存不足错误。
当可用内存不足以让Java虚拟机分配给一个对象时抛出该错误。
ng.StackOverflowError堆栈溢出错误。
当一个应用递归调用的层次太深而导致堆栈溢出时抛出该错误。
ng.ThreadDeath线程结束。
当调用Thread类的stop方法时抛出该错误，用于指示线程结束。
ng.UnknownError未知错误。
用于指示Java虚拟机发生了未知严重错误的情况。
ng.UnsatisfiedLinkError未满足的链接错误。
当Java虚拟机未找到某个类的声明为native方法的本机语言定义时抛出。
ng.UnsupportedClassVersionError不支持的类版本错误。
当Java虚拟机试图从读取某个类文件，但是发现该文件的主、次版本号不被当前Java虚拟机支持的时候，抛出该错误。
ng.VerifyError验证错误。
当验证器检测到某个类文件中存在内部不兼容或者安全问题时抛出该错误。
ng.VirtualMachineError虚拟机错误。
用于指示虚拟机被破坏或者继续执行操作所需的资源不足的情况。
ng.ArithmeticException算术条件异常。
譬如：整数除零等。
ng.ArrayIndexOutOfBoundsException数组索引越界异常。
当对数组的索引值为负数或大于等于数组大小时抛出。
ng.ArrayStoreException数组存储异常。
当向数组中存放非数组声明类型对象时抛出。
ng.ClassCastException类造型异常。
假设有类A和B（A不是B的父类或子类），O是A的实例，那么当强制将O构造为类B的实例时抛出该异常。
该异常经常被称为强制类型转换异常。
ng.ClassNotFoundException找不到类异常。
当应用试图根据字符串形式的类名构造类，而在遍历CLASSPAH 之后找不到对应名称的class文件时，抛出该异常。
ng.CloneNotSupportedException不支持克隆异常。
当没有实现Cloneable接口或者不支持克隆方法时,调用其clone()方法则抛出该异常。
ng.EnumConstantNotPresentException枚举常量不存在异常。
当应用试图通过名称和枚举类型访问一个枚举对象，但该枚举对象并不包含常量时，抛出该异常。
ng.Exception根异常。
用以描述应用程序希望捕获的情况。
ng.IllegalAccessException违法的访问异常。
当应用试图通过反射方式创建某个类的实例、访问该类属性、调用该类方法，而当时又无法访问类的、属性的、方法的或构造方法的定义时抛出该异常。
ng.IllegalMonitorStateException违法的监控状态异常。
当某个线程试图等待一个自己并不拥有的对象（O）的监控器或者通知其他线程等待该对象（O）的监控器时，抛出该异常。
ng.IllegalStateException违法的状态异常。
当在Java环境和应用尚未处于某个方法的合法调用状态，而调用了该方法时，抛出该异常。
ng.IllegalThreadStateException违法的线程状态异常。
当县城尚未处于某个方法的合法调用状态，而调用了该方法时，抛出异常。
ng.IndexOutOfBoundsException索引越界异常。
当访问某个序列的索引值小于0或大于等于序列大小时，抛出该异常。
ng.InstantiationException实例化异常。
当试图通过newInstance()方法创建某个类的实例，而该类是一个抽象类或接口时，抛出该异常。
ng.InterruptedException被中止异常。
当某个线程处于长时间的等待、休眠或其他暂停状态，而此时其他的线程通过Thread的interrupt方法终止该线程时抛出该异常。
ng.NegativeArraySizeException数组大小为负值异常。
当使用负数大小值创建数组时抛出该异常。
ng.NoSuchFieldException属性不存在异常。
当访问某个类的不存在的属性时抛出该异常。
ng.NoSuchMethodException方法不存在异常。
当访问某个类的不存在的方法时抛出该异常。
ng.NullPointerException空指针异常。
当应用试图在要求使用对象的地方使用了null时，抛出该异常。
譬如：调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等。
ng.NumberFormatException数字格式异常。
当试图将一个String转换为指定的数字类型，而该字符串确不满足数字类型要求的格式时，抛出该异常。
ng.RuntimeException运行时异常。
是所有Java虚拟机正常操作期间可以被抛出的异常的父类。
ng.SecurityException安全异常。
由安全管理器抛出，用于指示违反安全情况的异常。
ng.StringIndexOutOfBoundsException字符串索引越界异常。
当使用索引值访问某个字符串中的字符，而该索引值小于0或大于等于序列大小时，抛出该异常。
ng.TypeNotPresentException类型不存在异常。
当应用试图以某个类型名称的字符串表达方式访问该类型，但是根据给定的名称又找不到该类型是抛出该异常。
该异常与ClassNotFoundException的区别在于该异常是unchecked（不被检查）异常，而ClassNotFoundException是checked（被检查）异常。
ng.UnsupportedOperationException不支持的方法异常。
指明请求的方法不被支持情况的异常。
异常javax.servlet.jsp.JspException: Cannot retrieve mapping for action /Login （/Login是你的action名字）可能原因action没有再struts-config.xml 中定义，或没有找到匹配的action，例如在JSP文件中使用 <html:form action="Login.do".将表单提交给Login.do处理，如果出现上述异常，请查看struts-config.xml中的定义部分，有时可能是打错了字符或者是某些不符合规则，可以使用strutsconsole工具来检查。
-----------------------------------------------------------------------------------------------------------------异常org.apache.jasper.JasperException: Cannot retrieve definition for form bean null可能原因这个异常是因为Struts根据struts-config.xml中的mapping没有找到action期望的form bean。
大部分的情况可能是因为在form-bean中设置的name属性和action中设置的name属性不匹配所致。
换句话说，action和form都应该各自有一个name属性，并且要精确匹配，包括大小写。
这个错误当没有name属性和action关联时也会发生，如果没有在action中指定name属性，那么就没有name属性和action相关联。
当然当action制作某些控制时，譬如根据参数值跳转到相应的jsp页面，而不是处理表单数据，这是就不用name属性，这也是action的使用方法之一。