java异常

java异常的定义

不要指望你的程序永远不会出错。Java程序运行过程中所发生的异常事件，比如除数为零、文件找不到等，就叫做java异常。Java把异常当作一个对象来处理，使用Throwable类及其子类来描述异常。

java异常体系结构

Thorwable类所有异常和错误的超类，有两个子类Error和Exception，分别表示错误和异常。 Exception又分为RuntimeException和非RuntimeException。包括Error与RuntimeException及其子类属于非检查性（unchecked）异常，而Exception除了RuntimeException及其子类的其他非RuntimeException及其子类是检查性（checked）异常。

java需要异常处理的对象

Error是指JVM系统内部错误、资源耗尽等严重情况，在这种情况下，程序会终止运行。Error是一种unchecked Exception，没有必要捕捉Error，你只需要通知用户即可。

RuntimeException是表示执行期间发生的任何意外事故中被抛出的异常；也就是说，它表示如果程序运行正常，从不会发生的情况。这类异常皆由Java系统自动抛出，不需要手工抛出。Error和RuntimeException都是unchecked Exception，通常都不需要程序员来捕捉和处理，因为一个正确设计和实现的程序从不出现这种异常，通常对它不做处理。RuntimeException是程序存在逻辑错误，要对程序进行修改。

Checked Exception异常。JAVA 语言规定必须对checked Exception作处理，编译器会对此作检查，要么在方法体中声明抛出checked Exception，要么使用catch语句捕获checked Exception进行处理，不然不能通过编译。

Java异常处理机制

Java程序的执行过程中如出现异常，会自动生成一个异常类对象，该异常类对象将被提交给Java运行时系统，这个过程成为抛出（throw）异常。

当Java运行时系统接收到异常对象时，会寻找能处理这一异常的代码并把当前异常对象交给其处理，这一过程称为捕获（catch）异常。

如果Java运行时系统找不到可以捕获异常的方法，则运行时系统将终止，相应的Java程序也将退出。

程序员通常只能处理违例（Exception）,而对错误（Error）无能为力。

如果方法中的一个语句抛出一个没有在相应的try/catch块中处理的异常，那么这个异常就被抛出到调用它方法中。如果异常也没有在调用方法中被处理，它就被抛出到该方法的调用程序。这个过程要一直延续到异常被处理。如果异常到这时还没被处理，它便回到main()，而且，即使main()不处理它，那么，该异常就异常地中断程序。

Java异常处理的方法

try{
//可能会抛出特定异常的代码段
}catch(MyExceptionType myException){
//如果myException被抛出，则执行这段代码
} catch(Exception otherException){
//如果另外的异常otherException被抛出，则执行这段代码
}finally{
//无条件执行的语句
}

在可能出现异常的地方throw（抛出）异常。异常可以由JVM抛出，也可以手工抛出。手工抛出异常用throw关键字，在可能出现异常的代码块放在try关键字的块中。RuntimeException可以由JVM自动抛出，不需要throw手动抛出。

要处理异常，先将能够抛出异常的代码放入try块中，然后再创建相应的catch块的列表，每个可以被抛出异常都有一个。如果生成的异常与catch中提到的相匹配，那么catch条件的块语句就被执行。在try块之后，可能有许多catch块，每一个都处理不同的异常。catch只有第一个匹配try块中的异常起作用，下面的其他catch块都不会执行。因此通常把子类或者更详细的异常放在前面，不父类或者范围广的异常放在后面，Exception可以放在最后面，以此来保证捕获到最精准的异常类型。

finally语句总是要执行的，不管是否抛出异常。只有唯一的一种情况finally语句不执行，就是在前边的块中有System.exit（）的方法被执行时。如果一个return语句被嵌入try块内的代码中，那么，finally块中的代码应在return前执行。

public class Excep {
public static void main(String[] args) {
int c = 0;
try{
int a = 6;
int b = 0;
c = a / b;
System.out.println(c);
}catch(ArithmeticException e){
System.out.println("ArithmeticException-----------");
e.printStackTrace();
}
catch(Exception e){
System.out.println("Exception------------------");
e.printStackTrace();
}
finally{
System.out.println("Finally------------------");
}
}
}
//运行结果为
//ArithmeticException-----------
//Finally------------------

public class Excep {
public static void main(String[] args) {
int c = 0;
try{
int a = 6;
return;
}
catch(Exception e){
System.out.println("Exception------------------");
e.printStackTrace();
}
finally{
System.out.println("Finally------------------");
}
}
}
//运行结果为：Finally------------------

当把return换成System.exit(0)时，finally块中的内容就不能执行了。

处理异常or抛出异常？

为了写出健壮的代码，Java编程语言要求，当一个方法发生Exception（不包括Error或RuntimeException）时，该方法必须决定如果出现问题该采取一种措施。

这种措施有两种：

1.直接处理异常。通过将try｛｝catch（）｛｝块纳入其代码中，在这里捕获给被命名为属于某个超类的异常，并调用方法处理它。即使catch块是空的，这也算是处理情况。

2.或者抛出异常让调用该方法的代码处理该异常。让被调用的方法表示它将不处理异常，而且该异常将被抛回到它所遇到的调用方法中。它是按如下所示通过用throws子句标记的该调用方法的声明来实现的：

public void reader() throws IOException

关键字throws之后是所有异常的列表，方法可以抛回到它的调用程序中。尽管这里只显示了一个异常，如果有成倍的可能的异常可以通过该方法被抛出，那么，可以使用逗号分开的列表。

public void reader() throws IOException，FileNotFoundException{}

是选择处理异常，还是选择抛出一个异常取决于是否给你自己或你的调用程序一个更合适的候选的办法来处理异常。如果有足够的信息来处理这个异常，你就可以不用抛出给调用者，而直接处理这个异常；而如果当前信息不足以或者你不知道如何处理，就可以把异常信息抛出给上一层调用者。

自定义异常

所谓自定义异常，通常就是定义一个类，去继承Exception类或者它的子类。因为异常必须直接或者间接地继承自Exception类。

public class MyException extends Exception{
MyException(){
super();
}
MyException(String message){
super(message);
}
}
public class TestException {
public void notZero(int i) throws MyException{
if(i == 0)
{
throw new MyException("参数不能为0");
}
else{
System.out.println("传入的参数为： "+i);
}
}
public static void main(String[] args) {
TestException t = new TestException();
try {
t.notZero(0);
} catch (MyException e) {
e.printStackTrace();
}finally{
System.out.println("finally");
}
}
}
//运行结果为：
/*test.MyException: 参数不能为0
at test.TestException.notZero(TestException.java:7)
at test.TestException.main(TestException.java:16)
finally
*/

注意当方法中使用throw抛出检查性异常时，在方法名后要加上throws+抛出的异常类型。