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）。
- 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的使用方法之一。