展开全部
 
 
1. java.lang.nullpointerexception
 
 
这个异常e68a84e8a2ad62616964757a686964616f31333363376463大家肯定都经常遇到，异常的解释是"程序遇上了空指针"，简单地说就是调用了未经初始化的对象或者是不存在的对象，这个错误经常出现在创建图片，调用数组这些操作中，比如图片未经初始化，或者图片创建时的路径错误等等。对数组操作中出现空指针，很多情况下是一些刚开始学习编程的朋友常犯的错误，即把数组的初始化和数组元素的初始化混淆起来了。数组的初始化是对数组分配需要的空间，而初始化后的数组，其中的元素并没有实例化，依然是空的，所以还需要对每个元素都进行初始化(如果要调用的话)
 
 
2. java.lang.classnotfoundexception
 
 
这个异常是很多原本在jb等开发环境中开发的程序员，把jb下的程序包放在wtk下编译经常出现的问题，异常的解释是"指定的类不存在"，这里主要考虑一下类的名称和路径是否正确即可，如果是在jb下做的程序包，一般都是默认加上package的，所以转到wtk下后要注意把package的路径加上。
 
 
3. java.lang.arithmeticexception
 
 
这个异常的解释是"数学运算异常"，比如程序中出现了除以零这样的运算就会出这样的异常，对这种异常，大家就要好好检查一下自己程序中涉及到数学运算的地方，公式是不是有不妥了。
 
 
4. java.lang.arrayindexoutofboundsexception
 
 
这个异常相信很多朋友也经常遇到过，异常的解释是"数组下标越界"，现在程序

 
异常指不期而至的各种状况，如：文件找不到、网络连接失败、非法参数等。异常是一个事件，它发生在程序运行期间，干扰了正常的指令流程。Java通 过API中Throwable类的众多子类描述各种不同的异常。因而，Java异常都是对象，是Throwable子类的实例，描述了出现在一段编码中的 错误条件。当条件生成时，错误将引发异常。
 
Java异常类层次结构图：
 

 
在 Java 中，所有的异常都有一个共同的祖先 Throwable(可抛出)。Throwable 指定代码中可用异常传播机制通过 Java 应用程序传输的任何问题的共性。
 
Throwable： 有两个重要的子类：Exception(异常)和 Error(错误)，二者都是 Java 异常处理的重要子类，各自都包含大量子类。
 
Error(错误):是程序无法处理的错误，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM(Java 虚拟机)出现的问题。例如，Java虚拟机运行错误(Virtual MachineError)，当 JVM 不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError。这些异常发生时，Java虚拟机(JVM)一般会选择线程终止。
 
这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时，如Java虚拟机运行错误(Virtual MachineError)、类定义错误(NoClassDefFoundError)等。这些错误是不可查的(因为不知道什么时候会出现这类问题，不好指定同时也没有定义)，因为它们在应用程序的控制和处理能力之 外，而且绝大多数是程序运行时不允许出现的状况。对于设计合理的应用程序来说，即使确实发生了错误，本质上也不应该试图去处理它所引起的异常状况。在 Java中，错误通过Error的子类描述。
 
Exception(异常):是程序本身可以处理的异常(很多错误提前可以预知如除数为0就会报错)。
 
Exception 类有一个重要的子类 RuntimeException。RuntimeException 类及其子类表示“JVM 常用操作”引发的错误。例如，若试图使用空值对象引用、除数为零或数组越界，则分别引发运行时异常(NullPointerException、ArithmeticException)和 ArrayIndexOutOfBoundException。
 
注意：异常和错误的区别：异常能被程序本身可以处理，错误是无法处理。
 
Java的异常(包括Exception和Error)按照编译器是否在编译期间检查分为可查的异常(checked exceptions)和不可查的异常(unchecked exceptions)。
 
可查异常(编译器要求必须处置的异常)：正确的程序在运行中，很容易出现的、情理可容的异常状况。可查异常虽然是异常状况，但在一定程度上它的发生是可以预计的，而且一旦发生这种异常状况，就必须采取某种方式进行处理。
 
除了RuntimeException及其子类(编译器不做检查如空指针异常)以外，其他的Exception类及其子类都属于可查异常。这种异常的特点是Java编译器会检查它，也就是说，当程序中可能出现这类异常，要么用try-catch语句捕获它，要么用throws子句声明抛出它，否则编译不会通过。
 
不可查异常(编译器不要求强制处置的异常):包括运行时异常(RuntimeException与其子类)和错误(Error)。
 
Exception 这种异常分两大类运行时异常和非运行时异常(编译异常)。程序中应当尽可能去处理这些异常。
 
按照程序执行的过程划分
 
运行时异常：都是RuntimeException类及其子类异常，如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。运行时异常的特点是Java编译器不会检查它，也就是说，当程序中可能出现这类异常，即使没有用try-catch语句捕获它，也没有用throws子句声明抛出它，也会编译通过(  如果所有方法都层层上抛获取的异常，最终JVM会进行处理，处理也很简单，就是打印异常消息和堆栈信息。如果抛出的是Error或RuntimeException，则该方法的调用者可选择处理该异常)。
 
非运行时异常 (编译异常)：是RuntimeException以外的异常，类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常，一般情况下不自定义检查异常。
 
Java中的异常处理机制
 
在 Java 应用程序中，异常处理机制为：抛出异常，捕捉异常。
 
抛出异常：当一个方法出现错误引发异常时，方法创建异常对象并交付运行时系统，异常对象中包含了异常类型和异常出现时的程序状态等异常信息。运行时系统负责寻找处置异常的代码并执行。
 
捕获异常：在方法抛出异常之后，运行时系统将转为寻找合适的异常处理器(exception handler)。潜在的异常处理器是异常发生时依次存留在调用栈中的方法的集合。当异常处理器所能处理的异常类型与方法抛出的异常类型相符时，即为合适 的异常处理器。运行时系统从发生异常的方法开始，依次回查调用栈中的方法，直至找到含有合适异常处理器的方法并执行。当运行时系统遍历调用栈而未找到合适 的异常处理器，则运行时系统终止。同时，意味着Java程序的终止。
 
对于运行时异常、错误或可查异常，Java技术所要求的异常处理方式有所不同。
 
由于运行时异常(RuntimeException及其子类)的不可查性，为了更合理、更容易地实现应用程序，Java规定，运行时异常将由Java运行时系统自动抛出，允许应用程序忽略运行时异常(如：“除数为0”等ArithmeticException，是RuntimException的子类。而运行时异常将由运行时系统自动抛出，不需要使用throw语句)。
 
对于方法运行中可能出现的Error，当运行方法不欲捕捉时，Java允许该方法不做任何抛出声明。因为，大多数Error异常属于永远不能被允许发生的状况，也属于合理的应用程序不该捕捉的异常(在编写程序时不需要考虑Error)。
 
对于所有的可查异常(除了RuntimeException及其子类)，Java规定：一个方法必须捕捉，或者声明抛出方法之外。也就是说，当一个方法选择不捕捉可查异常时，它必须声明将抛出异常，因为Java编译器会检查它，也就是说，当程序中可能出现这类异常，要么用try-catch语句捕获它，要么用throws子句声明抛出它，否则编译不会通过。
 
能够捕捉异常的方法，需要提供相符类型的异常处理器。所捕捉的异常，可能是由于自身语句所引发并抛出的异常，也可能是由某个调用的方法或者Java运行时 系统等抛出的异常。也就是说，一个方法所能捕捉的异常，一定是Java代码在某处所抛出的异常。简单地说，异常总是先被抛出，后被捕捉的。
 
任何Java代码都可以抛出异常，如：自己编写的代码、来自Java开发环境包中代码，或者Java运行时系统。无论是谁，都可以通过Java的throw语句抛出异常。
 
1.从方法中抛出的任何异常都必须使用throws子句。
 
2.捕捉异常通过try-catch语句或者try-catch-finally语句实现。
 
3.总体来说，Java规定：对于可查异常必须捕捉、或者声明抛出(throw)。允许忽略不可查的RuntimeException和Error。
 
例1：
 
packagecn.czbk.no9;public classExceprtionTest {/***@paramargs*/
 
public static voidmain(String[] args) {int a=6;int b=0;/*** 除数为0,属于RuntimeException,属于不可查异常
 
* 编译器不会对其做检查。
 
* 运行时异常由系统jvm自动抛出不需要主动throw*/
 
int c=a/b;
 
System.out.println(c);
 
}
 
}
 
运行时异常由系统即JVM主动抛出不需要手动throw
 

 
那么我们要让程序正常通过，就要处理这个运行时异常。
 
packagecn.czbk.no9;public classExceprtionTest {/***@paramargs*/
 
public static voidmain(String[] args) {int a=6;int b=2;/*** 除数为0,属于RuntimeException,属于不可查异常
 
* 编译器不会对其做检查。
 
* 运行时异常由系统jvm自动抛出不需要主动throw*/
 
try{if(b==0){//在运行过程中出现的异常都是属于上面讲的异常类的实例
 
throw newArithmeticException();//由于是RuntimeException所以可以不用显示抛出
 
}else{
 
System.out.println("a/b="+(a/b));
 
}
 
}catch(ArithmeticException e) {//TODO: handle exception
 
System.out.println("除数不能为0");
 
}
 
System.out.println("程序正常结束！");
 
}
 
}
 
try－catch-finally语句
 
try{//可能会发生异常的程序代码
 
} catch(Type1 id1) {//捕获并处理try抛出的异常类型Type1
 
} catch(Type2 id2) {//捕获并处理try抛出的异常类型Type2
 
} finally{//无论是否发生异常，都将执行的语句块
 
}
 
实例：
 
packagecn.czbk.no9;importjava.util.Scanner;public classExceptionTest1 {public static voidmain(String[] args) {int[] intArray = new int[4];int a = 20;int c=0;//数组初始化赋值
 
for (int i = 0; i <= 3; i++) {
 
intArray[i]=i;
 
}//根据输入的值判断循环次数
 
Scanner in=newScanner(System.in);
 
String text=in.nextLine();//将输入的String转为Int
 
int x=Integer.parseInt(text);for (int i = x; i >= 0; i--) {//将不可查异常即RuntimeException进行捕获处理
 
try{int b =intArray[i];
 
c=a/b;
 
}/*** 如果抛出的异常对象属于catch子句的异常类，或者属于该异常类的子类，则认为生成的异常对象与catch块捕获的异常类型相匹配。
 
* 一旦某个catch捕获到匹配的异常类型，将进入异常处理代码。
 
* 一经处理结束，就意味着整个try-catch语句结束。
 
* 其他的catch子句不再有匹配和捕获异常类型的机会。
 
* 对于有多个catch子句的异常程序而言，应该尽量将捕获底层异常类的catch子 句放在前面，
 
* 同时尽量将捕获相对高层的异常类的catch子句放在后面。
 
* 否则，捕获底层异常类的catch子句将可能会被屏蔽。*/
 
catch(ArrayIndexOutOfBoundsException e) {//TODO: handle exception
 
System.out.println("数组下标越界，原数组中没有intArray["+i+"]");
 
}catch(ArithmeticException e) {//TODO: handle exception
 
System.out.println("intArray[" + i + "]" + "除数不能为0");
 
}catch(Exception e) {//TODO: handle exception
 
System.out.println("其他未想到的运行时异常");
 
}finally{
 
System.out.println("i为"+i+"计算结果 a/b="+a+"/"+intArray[i]+"="+c);
 
}
 
}
 
}
 
}
 
总结：
 
try 块：用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。
 
catch 块：用于处理try捕获到的异常。
 
finally 块：无论是否捕获或处理异常，finally块里的语句都会被执行。当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。在以下4种特殊情况下，finally块不会被执行：
 
1)在finally语句块中发生了异常。
 
2)在前面的代码中用了System.exit()退出程序。
 
3)程序所在的线程死亡。
 
4)关闭CPU。
 

 
抛出异常
 
1. throws抛出异常
 
methodname throwsException1,Exception2,..,ExceptionN
 
{
 
}
 
方法名后的throws Exception1,Exception2,...,ExceptionN 为声明要抛出的异常列表。当方法抛出异常列表的异常时，方法将不对这些类型及其子类类型的异常作处理，而抛向调用该方法的方法，由他去处理。例如：
 
Throws抛出异常的规则：
 
1) 如果是不可查异常(unchecked exception)，即Error、RuntimeException或它们的子类，那么可以不使用throws关键字来声明要抛出的异常，编译仍能顺利通过，但在运行时会被系统抛出。
 
2)必须声明方法可抛出的任何可查异常(checked exception)。即如果一个方法可能出现受可查异常，要么用try-catch语句捕获，要么用throws子句声明将它抛出，否则会导致编译错误
 
3)仅当抛出了异常，该方法的调用者才必须处理或者重新抛出该异常。当方法的调用者无力处理该异常的时候，应该继续抛出，而不是囫囵吞枣。
 
4)调用方法必须遵循任何可查异常的处理和声明规则。若覆盖一个方法，则不能声明与覆盖方法不同的异常。声明的任何异常必须是被覆盖方法所声明异常的同类或子类。
 
2. 使用throw抛出异常
 
void method1() throws IOException{} //合法//编译错误，必须捕获或声明抛出IOException
 
voidmethod2(){
 
method1();
 
}//合法，声明抛出IOException
 
void method3()throwsIOException {
 
method1();
 
}//合法，声明抛出Exception，IOException是Exception的子类
 
void method4()throwsException {
 
method1();
 
}//合法，捕获IOException
 
voidmethod5(){try{
 
method1();
 
}catch(IOException e){…}
 
}//编译错误，必须捕获或声明抛出Exception
 
voidmethod6(){try{
 
method1();
 
}catch(IOException e){throw newException();}
 
}//合法，声明抛出Exception
 
void method7()throwsException{try{
 
method1();
 
}catch(IOException e){throw newException();}
 
}
 
判断一个方法可能会出现异常的依据如下：
 
1)方法中有throw语句。例如，以上method7()方法的catch代码块有throw语句。
 
2)调用了其他方法，其他方法用throws子句声明抛出某种异常。例如，method3()方法调用了method1()方法，method1()方法声明抛出IOException，因此，在method3()方法中可能会出现IOException。
 
throw总是出现在函数体中，用来抛出一个Throwable类型的异常。程序会在throw语句后立即终止，它后面的语句执行不到，然后在包含它的所有try块中(可能在上层调用函数中)从里向外寻找含有与其匹配的catch子句的try块。
 
我们知道，异常是异常类的实例对象，我们可以创建异常类的实例对象通过throw语句抛出。该语句的语法格式为：
 
throw new exceptionname;
 
例如抛出一个IOException类的异常对象：
 
throw new IOException;
 
要注意的是，throw 抛出的只能够是可抛出类Throwable 或者其子类的实例对象。下面的操作是错误的：
 
throw new String("exception");
 
这是因为String 不是Throwable 类的子类。
 
如果抛出了检查异常，则还应该在方法头部声明方法可能抛出的异常类型。该方法的调用者也必须检查处理抛出的异常。
 
如果所有方法都层层上抛获取的异常，最终JVM会进行处理，处理也很简单，就是打印异常消息和堆栈信息。如果抛出的是Error或RuntimeException，则该方法的调用者可选择处理该异常。
 
packagecn.czbk.no9;public classExceptionTest3 {public void pop() throwsMyException{
 
String s="测试用";throw newMyException(s);
 
}public static void main(String[] args) throwsMyException{
 
ExceptionTest3 et=newExceptionTest3();
 
et.pop();
 
}
 
}class MyException extendsException{
 
String message;publicMyException(String errorMessage){
 
message=errorMessage;
 
}publicString getMessage(){returnmessage;
 
}
 
}
 
在main函数继续抛出的话会在运行后会显示如下内容
 

 
如果不抛出而是选择处理的话如下所示
 
packagecn.czbk.no9;public classExceptionTest3 {public void pop() throwsMyException{
 
String s="测试用";throw newMyException(s);
 
}public static voidmain(String[] args){
 
ExceptionTest3 et=newExceptionTest3();try{
 
et.pop();
 
}catch(MyException e) {//TODO: handle exception
 
e.getPrintMessage();
 
}
 
}
 
}class MyException extendsException{
 
String message;publicMyException(String errorMessage){
 
message=errorMessage;
 
}public voidgetPrintMessage(){
 
System.out.println(message);
 
}
 
}
 

 
4.4 Throwable类中的常用方法
 
注意：catch关键字后面括号中的Exception类型的参数e。Exception就是try代码块传递给catch代码块的变量类型，e就是变量名。catch代码块中语句"e.getMessage();"用于输出错误性质。通常异常处理常用3个函数来获取异常的有关信息:
 
getCause()：返回抛出异常的原因。如果 cause 不存在或未知，则返回 null。
 
getMeage()：返回异常的消息信息。
 
printStackTrace()：对象的堆栈跟踪输出至错误输出流，作为字段 System.err 的值。
 
有时为了简单会忽略掉catch语句后的代码，这样try-catch语句就成了一种摆设，一旦程序在运行过程中出现了异常，就会忽略处理异常，而错误发生的原因很难查找。
 
Java常见异常
 
在Java中提供了一些异常用来描述经常发生的错误，对于这些异常，有的需要程序员进行捕获处理或声明抛出，有的是由Java虚拟机自动进行捕获处理。Java中常见的异常类:
 
1.RuntimeException子类:
 
1、 java.lang.ArrayIndexOutOfBoundsException
 
数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。
 
2、java.lang.ArithmeticException
 
算术条件异常。譬如：整数除零等。
 
3、java.lang.NullPointerException
 
空指针异常。当应用试图在要求使用对象的地方使用了null时，抛出该异常。譬如：调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等
 
4、java.lang.ClassNotFoundException
 
找不到类异常。当应用试图根据字符串形式的类名构造类，而在遍历CLASSPAH之后找不到对应名称的class文件时，抛出该异常。
 
5、java.lang.NegativeArraySizeException  数组长度为负异常
 
6、java.lang.ArrayStoreException 数组中包含不兼容的值抛出的异常
 
7、java.lang.SecurityException 安全性异常
 
8、java.lang.IllegalArgumentException 非法参数异常
 
2.IOException
 
IOException：操作输入流和输出流时可能出现的异常。
 
EOFException   文件已结束异常
 
FileNotFoundException   文件未找到异常
 
3.其他
 
ClassCastException    类型转换异常类
 
ArrayStoreException  数组中包含不兼容的值抛出的异常
 
SQLException   操作数据库异常类
 
NoSuchFieldException   字段未找到异常
 
NoSuchMethodException   方法未找到抛出的异常
 
NumberFormatException    字符串转换为数字抛出的异常
 
StringIndexOutOfBoundsException 字符串索引超出范围抛出的异常
 
IllegalAccessException  不允许访问某类异常
 
InstantiationException  当应用程序试图使用Class类中的newInstance()方法创建一个类的实例，而指定的类对象无法被实例化时，抛出该异常

 
java 实验九异常处理
 
《面向对象程序设计》实验报告
 
合肥院学院计算机科学与技术系
 
实验名称 异常处理 日期 2014年11月26日
 
姓名/学号 代震/1304092039 专业/班级 软件工程(2)班
 
指导老师 吴晓琴 成绩
 
一、实验目的：(详见指导书，宋体小四)
 
1、理解 java 语言中独特的异常处理机制掌握正确地使用捕获异常和声明抛弃异常的两种异常处理的方法理解抛异常和声明抛异常的区别与联系捕获异常和声明抛弃异常的两种异常处理的方法捕获Integer.parseInt()产生的异常从命令行得到5个整数，放入一整型数组，然后打印输出，要求：如果输入数据不为整数，要捕获Integer.parseInt()产生的异常，显示“请输入整数”，捕获输入参数不足5个的异常(数组越界)，显示“请输入至少5个整数”。写一个方法void sanjiao(int a,int b,int c)，判断三个参数是否能构成一个三角形，如果不能则抛出异常IllegalArgumentException，显示异常信息a,b,c+”不能构成三角形”，如果可以构成则显示三角形三个边长，在主方法中得到命令行输入的三个整数，调用此方法，并捕获异常。自定义类Sanj，其中有成员 x,y,z,作为三边长，构造方法Sanj(a,b,c)分别给x,y,z赋值,方法求面积getArea和显示三角形信息(三个边长)showInfo，这2个方法中当三条边不能构成一个三角形时要抛出自定义异常NotSanjiaoException，否则显示正确信息。在另外一个类中的主方法中构造一个Sanj对象(三边为命令行输入的三个整数)，显示三角形信息和面积，要求捕获异常。参考下面的程序，试修改程序，捕获相关异常，使得程序能正常运行。[提示：用错误数据测试，即可得到异常类名，运行时主方法参数输入 abc 测试]public class StringIndexOutOf{
 
public static void main(String args[]){
 
System.out.println("字符串索引越界异常");String str=args[0]; System.out.println(“第四个字符为 ”+str.charAt(3));int aa=Integer.parseInt(args[0]); System.out.println(“平方为 ”+aa*aa);}
 
}
 
实验过程：
 
1、(第1题) 使用try…..catch…. finally语句对Integer.parseInt()产生的异常捕获方法void sanjiao(int a,int b,int c)抛出异常IllegalArgumentException(),),再定义main方法调用此方法，…..catch…. finally语句并捕获异常 定义三角形类抛出异常方法捕获异常
 
四、实验中的问题思考及讨论：(列出你实验中出现的问题，解决的问题和解决的思路实验： 简单、准确的总结次实验的主要内容，个人收获 java 语言中独特的异常处理机制正确地使用捕获异常和声明抛弃异常的两种异常处理的方法抛异常和声明抛异常的区别与联系?
 
1、
 
import java.util.Scanner;
 
public class Te9_1{
 
public static void main(String args[]){
 
try{
 
if(args.length<5){
 
ArrayIndexOutOfBoundsException e=new ArrayIndexOutOfBoundsException();
 
throw e;
 
}
 
for(int i=0;i<=4;i++){
 
Integer.parseInt(args[i]);
 
}
 
for(int i=0;i<=4;i++){
 
System.out.print(args[i]+" ");
 
}
 
}
 
catch(ArrayIndexOutOfBoundsException e){
 
System.out.println("请输入至少5个整数!");
 
}
 
catch(NumberFormatException e){
 
System.out.println("请输入整数!");
 
}
 
}
 
}
 
2、
 
import java.util.Scanner;
 
public class Te9_2{
 
public static void m

 

 
java之异常
 

 
(1)任何一种程序设计语言设计的程序在运行时都可能出现错误。
 
(2)捕获错误最理想的是在编译期间，但有的错误只有在运行时才会发生。
 
(3)对于这些错误，一般有两种解决方法：
 
遇到错误就终止程序运行；
 
由程序员在编写程序时，就考虑到可能出现的错误，并进行错误的检测、错误的提示以及错误的处理；
 
那么什么是编译，什么是运行呢？
 
编译：又分为编译和链接两个过程。编译是将源文件转换为机器可识别的二进制文件。链接是将这些二进制文件组合成系统可以执行的可执行文件。
 
运行：将编译出来的可执行程序放在系统中进行运行。
 
Java异常：在java语言中，将程序执行中发生的不正常情况称为异常。
 
java中的异常用于处理非预期的情况，如文件没找到、网络错误、非法的参数等。
 
java程序运行过程中的异常可分为两类：
 
Error：JVM系统内部错误、资源耗尽等严重情况；
 
Exception：其它因编程原因或偶然的外在因素导致的一致性问题，例如空指针访问、试图读取不存在的文件、网络连接中断等。
 
异常处理机制：
 
在编写程序时，经常要在可能出错误的地方加上检测的代码；
 
java异常处理：java采用异常处理机制，将异常处理的程序代码集中在一起，与正常的程序代码分开，是的程序简洁，并利于维护；
 
说明：
 
java提供的是异常处理的抓跑模型；
 
java程序的执行过程中若果出现异常，会自动生成一个异常类对象，该异常对象将被提交给java运行时系统，这个过程称为抛出异常；
 
如果在一个方法内抛出异常，该异常会被抛到调用的方法中，如果异常没有在调用方法中处理，他继续被抛给这个调用方法的调用者。这个过程会一直持续下去，直到异常被处理。这一个过程被称为捕获异常；
 
如果一个异常回到main()方法，并且main()也不处理，则程序运行终止；
 
程序员通常只能处理Eception，而对Error无能为力；
 

 
try{
 
//需要判断是否出现异常的语句
 
}catch(Exception e){
 
//捕获异常
 
}finally{
 
//无论是否出现异常，都会运行这里的代码
 
}
 

 
注意：如果有多个catch，在捕获到前面的异常后，后面的就不会再捕获了。
 
声明抛出异常
 
声明抛出异常是java中处理异常的第二种方式；
 
如果一个方法可能生成某种异常，但是并不能确定如何处理这个异常，则此方法应显示地声明抛出异常，表明该方法将不对这些异常进行处理，由该方法的调用者进行处理。
 
在方法中声明throws子句可以声明抛出异常的列表，throws后面的异常类型可以是方法中产生的异常类型，也可以是它的父类；
 
举例：public void readFile(String file) throws FileNotFoundException{
 
FileInputStream fis = new FileInputStream(file);
 
}
 

 
package myjava;
 
public class Test3 {
 
public static void main(String[] args) {
 
B b = new B();
 
try {
 
b.test();
 
}catch(Exception e){
 
e.printStackTrace();
 
}
 
}
 
}
 
class B{
 
int i;
 
public void test() throws Exception{
 
B b = null;
 
System.out.println(b.i);
 
}
 
}
 

 
输出：
 

 
注意：当父类方法抛出异常，子类方法继承父类对该方法进行重写时，也需要抛出异常，同时抛出的异常范围不能比父类的大。
 
人工抛出异常：
 
java异常类对象除在程序执行的过程中出现异常时由系统自动生成并抛出，也可根据人工创建并抛出；
 
首先要生成异常类对象，然后通过throw语句实现抛出操作；
 
可以抛出的异常必须是throwable或其子类的实例；
 

 
package myjava;
 
public class Test3 {
 
public static void main(String[] args) {
 
B b = new B();
 
try {
 
b.test(200);
 
}catch(Exception e){
 
e.printStackTrace();
 
}
 
}
 
}
 
class B{
 
int age;
 
public void test(int age) throws Exception{
 
if (age>=0 && age <= 100) {
 
System.out.println("合法");
 
}else {
 
throw new Exception("年龄不合法");
 
}
 
}
 
}
 

 
输出：
 

 
创建用户自定义异常类：用户自定义的异常类必须继承现有的异常类
 

 
package myjava;
 
public class Test3 {
 
public static void main(String[] args) {
 
B b = new B();
 
try {
 
b.regist(-1);
 
}catch(Exception e){
 
e.printStackTrace();
 
}
 
}
 
}
 
class B{
 
public void regist(int num) throws Exception{
 
if (num<0) {
 
throw new MyException("人数不能为负值",3);
 
}else {
 
System.out.println("登记人数"+num);
 
}
 
}
 
}
 
class MyException extends Exception{
 
private int idnumber;
 
public MyException(String message,int id) {
 
super(message);
 
this.idnumber = id;
 
}
 
public int getId() {
 
return idnumber;
 
}
 
}
 

 
输出：
 

 
然后就可以抛出异常：
 

 
package myjava;
 
public class Test3 {
 
public static void main(String[] args) {
 
B b = new B();
 
try {
 
b.message();
 
}catch(Exception e){
 
e.printStackTrace();
 
}
 
}
 
}
 
class B{
 
public void regist(int num) throws Exception{
 
if (num<0) {
 
throw new MyException("人数不能为负值",3);
 
}else {
 
System.out.println("登记人数"+num);
 
}
 
}
 
public void message() throws Exception {
 
try {
 
regist(-1);
 
}catch (MyException e){
 
System.out.println("登记失败，出错种类"+e.getId());
 
}
 
System.out.println("本次登记结束");
 
}
 
}
 
class MyException extends Exception{
 
private int idnumber;
 
public MyException(String message,int id) {
 
super(message);
 
this.idnumber = id;
 
}
 
public int getId() {
 
return idnumber;
 
}
 
}
 

 
输出：