Java中把所有非正常情况分为两种，Error错误和Exception异常，它们都继承自Throwable异常。
Error错误一般指与虚拟机相关的问题，如系统崩溃，虚拟机错误，动态链接失败等。这种错误是无法恢或不可捕获的，将导致应用程序中断。其子类有：IOError、ThreadDeath、LinkageError、AWTError
Exception异常指可以使用catch块来捕获，子类有IOException,RuntimeException,SQLException。其中RuntimeException运行时异常中常见的有IndexOutOfBoundsException数组越界异常,NullPointerException空指针异常,ClassCastException类转换异常。
异常捕获时，需遵循先捕获小异常，再捕获大异常。
Java7提供的多异常捕获
在java7以前，每个catch块只能捕获一种类型的异常。但从Java7开始，一个catch块可以捕获多种类型异常。
使用一个catch块捕获多种类型异常时，多种异常类型之间用竖线 | 隔开
捕获多种类型的异常时，异常变量有隐式的final修饰。因此程序不能对异常变量重新赋值。
public class MultiException{
public static void main(String[] args){
try{
int a = Integer.parseInt(args[0]);
int b = Integer.parseInt(argsp[1]);
int c = a/b;
System.out.println("你输入的两个数相除的结果是：" + c);
}
catch (IndexOutOfBoundsException | NumberFormatException | ArithmeticException ie){
System.out.println("程序发生了越界、数字格式异常、算术异常之一：" + c);
//捕获多种异常时，异常变量默认为final修饰，下面代码有错
ie = new ArithmeticException("test");
}
catch(Exception e)
{
System.out.println("未知异常：" );
//捕获一种异常时，异常变量没有final修饰，下面代码正确
e = new RuntimeException("test");
}
}
}访问异常信息：
如果程序需要在catch块中访问异常对象的相关信息，则可以通过访问catch块的后异常形参来获得。
所有异常对象都包含了如下几个常用的相关信息。
- getMessage():返回该异常的详细描述字符串
- printStackTrace():将该异常的跟踪栈信息输出到标准输出
- printStackTrace(PrintStream):将该异常的跟踪栈信息输出到指定输出流
- getStacktTrace():返回该异常的跟踪栈信息
使用finally回收资源
有时，程序在try块里打开了一些物理资源（例如数据库连接、网络连接、磁盘文件），这些物理资源都必须显式回收。不管try块中是否出现异常，也不管哪一个catch块被执行，甚至try块或catch块中执行了return语句，finally块总会被执行。
Java的垃圾回收机制不会回收任何物理资源，垃圾回收机制只能回收堆内存中对象所占用的内存
public class FinallyTest{
public static void main(String[] args)
{
FileInputStream fis = null;
try
{
fis = new FileInputStream("a.txt");
}
catch(IOException ioe)
{
System.out.println(ioe.getMessage());
//rerurn语句强制方法返回
return;
//使用exit退出虚拟机
//System.exit(1);
}
finally
{
//关闭磁盘文件
if(fis != null)
{
try
{
fis.close();
}
catch(IOException ioe)
{
ioe.printStackTrace();
}
}
System.out.println("执行finally块里的资源回收!");
}
}
}
使用在catch代码块中使用return语句，finally块依然会执行。然而使用System.exit(!)语句来退出虚拟机，则finally块将会失去执行的机会。除非在try块、catch块调用了退出虚拟机的方法，否则不管try块、catch块执行了怎样的代码，异常处理的finally块总会被执行。
通常，不要在finally块中调用return或throw等导致方法终止的语句，一旦在finally块中使用了return或throw语句，将会导致rerurn、throw语句失效。
异常处理的嵌套
正如以上代码中，finally块中也包含了一个完整的异常处理流程，这种在try块，catch块或finally块中包含完整的异常处理流程被称为异常处理的嵌套。
java7的自动关闭资源的try语句
FileInputStream fis = null;
try
{
fis = new FileInputStream("a.txt");
}
finally
{
//关闭磁盘文件，回收资源
if(fis != null)
{
fis.close();
}
}
Java7以前，不得不写的臃肿代码在Java7中改变了这种局面，Java7中增强了try语句的功能，它允许在try关键字后跟一对圆括号，圆括号可以声明、初始化一个或多个资源，此处的资源指的是那些必须在程序结束后显式关闭资源，比如数据库连接、网络连接等物理资源。需要注意的是，为了保证try语句可以正常关闭资源，这些资源实现类必须实现AutoCloseable或Closeable接口，实现这两个接口就必须实现close(）方法
Closeable是AutoCloseable的子接口，可以被自动关闭的资源类要么实现AutoCloseable接口，要么实现Closeable接口。Closeable接口中的方法声明抛出了IOException,因此它的实现类在实现close()方法时，只能声明抛出IOException或其子类，AutoCloseable接口里的close()方法声明抛出了Exception，因此它的实现类在实现close(）方法时可以声明抛出任何异常。
public class AutoCloseTest{
public static void main(String[] args){
throws IOException
{
try(
//声明、初始化两个可关闭的资源
//try语句会自动关闭这些资源
BufferedReader br = new BufferedReader(
new FileReader("AutoCloseTest.java"));
PrintStream ps = new PrintStream(new FileOutputStream("a.txt")))
{
System.out.println(br.readline());
ps.println("222");
}
}
}由于BufferedReader、PrintStream都实现了CLoseable接口，而且它们放在try语句中声明、初始化，所以try语句会自动关闭它们。因此上面的程序是安全的。
自动关闭资源的try语句相当于隐式的finally块。因此这个try语句可以既没有catch块，也没有finally块。
Checked异常和Runtime异常体系
只有Java支持Checked异常，其它语言都没有提供Checked异常。Java认为所以Checked异常都是可以被处理的异常，所以Java程序必须显式处理Checked异常。如果没有处理Checked异常，该程序在编译时就发生错误，无需通过编译。
Checked异常的处理方式有两种：
当知道如何处理异常时，使用try...catch进行捕获异常
当不知道何种异常，需要在定义该方法时声明抛出异常
Runtime异常更加灵活，Runtime异常无须显示的声明抛出，如果程序需要捕获异常Runtime异常，也可以使用try...catch块来实现
使用throws声明抛出异常
使用throws声明抛出异常的思路是，当前方法不知道如何处理这种类型的异常，该异常抛给上一级，如果main方法也不知道怎样处理，则交给JVM处理，JVM处理异常的方法是，打印异常的跟踪栈信息，并中止程序允许，这就是程序在遇到异常后自动结束的原因。“C#，Pthon，Rubby等语言没有Checked异常，所有的异常都是Runtime异常。
使用throw抛出异常
抛出异常
如果需要在程序中自行抛出异常，则应使用throw语句，throw语句可以单独使用，throw语句抛出的不是异常类，而是一个异常实例，而且每次只能抛出一个异常实例。
throw ExceptionInstance;如果throw语句抛出的异常是Checked异常，则该throw语句要么在try块中，显示捕获异常。要么放在一个带throw声明抛出的方法中，即把该异常交给该方法的调用者处理。如果throw语句抛出的是Runtime异常，则该语句应放在try块中，也无须在带throws声明抛出的方法中。
public class ThrowTest{
public static void main(String[] args)
{
throwChecked(-3);
throwRuntime(3);
public static void throwChecked(int n) throws Exception
{
if(a>0)
{
throw new Exception("n为正数”);
System.out.println(n);
}
}
public static void throwRuntime(int n)
{
if(a>0)
{
throw new RuntimeException("n为正数”);
System.out.println(n);
}
}
自行抛出Runtime异常比自行抛出Checked异常的灵活性更好。同样抛出Checked异常则可以让编译器提醒程序员必须处理该异常。
自定义异常类
通常程序很少会自行抛出系统异常，因为异常的类名也包含了该异常的有用信息。所有在选择抛出异常时，应该选择合适的异常类，从而可以明确地描述该异常情况。在这种情况，应用程序常常需要抛出自定义异常。
用户自定义异常都应该继承Exception基类，如果希望自定义Runtime异常，则应该继承RuntimeException基类。定义异常类时通常需要提供两个构造器：一个是无参数的构造器，另一个是带字符串参数的构造器，这个字符串将作为该异常对象的描述信息。
catch和throw同时使用
前面提到的异常处理方式有两种：
在出现异常的方法内捕获并处理异常，该方法的调用者将不能再次抛出异常。
该方法签名中声明抛出该异常，将异常完全交给方法调用者处理。
public class AuctionTest{
private double initPrice = 30.0;
//因为该方法显示抛出了AuctionException异常
//所以此处需要声明抛出了AuctionException
public void bid(String bidPrice){
throws AuctionException
{
double d = 0.0;
try
{
d = Double.parseDouble(bidPrice);
}
catch(Exception e)
{
//此处完成本方法中可以对异常执行的修复处理
//此处仅仅是在控制台打印异常的跟踪栈信息
e.printStackTrace();
//再次抛出自定义异常
throw new AuctionException(
“竞拍价必须是数值，"+”不能包含其它字符“）；
}
if(initPrice > d){
throw new AuctionException("竞拍价比起拍价低，"+"不允许竞拍");
}
initPrice =d;
}
public static void main(String[] args){
{
AuctionTest at = new AuctionTest();
try
{
at.bid("df");
}
catch (AuctionException ae)
{
//再次捕获到bid()方法的异常，并对该异常进行处理
System.err.println(ae.getMessage());
}
}
}这种catch和throw结合使用的情况在大型企业级应用中非常常用，企业级应用对异常的处理通常分为两个部分：1应用后台需要通过日志来记录异常发生的详细情况；2应用还需要根据异常向应用使用者传达某种提示。在这种情形下，所以异常需要两个方法共同完成，也就必须将catch和throw结合使用。
Java 7 增强的throw语句
对以下代码：
try
{
new FileOutputStream("a.txt");
}
catch(Exception ex)
{
ex.printStackTrace();
throw ex;
}从Java7开始，Java编译器会执行更细致的检查，Java编译器会检查throw语句异常的实际类型，这样编译器知道1代码实际上只可能排除FileNotFoundException异常。因此在方法签名中只要声明抛出FileNotFoundException异常即可。
public class ThrowTest2{
public static void main(String[] args)
//Java7会检查1号代码处可能抛出异常的实际类型
//因此此处只需声明抛出FileNotFoundException异常即可
throw FileNotFoundException
{
try
{
new FileOutputStream("a.txt");
}
catch(Exception ex)
{
ex.printStackTrace();
throw ex;
}
}异常链
把底层的原始异常直接传给用户是不负责任的表现。通常需要先捕获原始异常，然后抛出一个新的业务异常，新的业务异常中包含了对用户是提示信息，这种处理方式被称为异常转移。假设程序需要实现工资计算的方法，则程序应该采用如下结构的代码实现该方法。
public class AutoCloseTest{
public static void main(String[] args){
throws IOException
{
try(
//实现工资结算的业务逻辑
catch(SQLException sqle)
{
//把原始异常记录下来，留给管理员
...
//下面异常中的message就是对用户的提示
throw new SalExcetion("访问底层数据库出现异常”);
}
catch(Exception e)
{
//把原始异常记录下来，留个管理员
...
throw new SalException("系统出现未知异常");
}
}这种把原始异常信息隐藏起来，仅向上提供必要的异常提示信息的处理方式。可以保证底层异常不会扩散到表现层。可以避免向上暴露太多的实现细节。这完全符合面向对象的封装原则。这种把捕获异常然后接着抛出另一个异常，并把原始异常信息保存下路是一种典型的链式处理（23种设计模式之一：职责链之一），也被称为异常链。
在Jdk1.4之前，程序员必须把自己编写的代码来保持原始异常信息。从1.4开始，所以的Throwable的子类在构造器中都可以结束一个cause对象作为参数。这个cause就用来表示原始异常，这样可以把原始异常传递给新的异常。使得即时在当前位置创建并抛出象新的异常，你可可能通过这个异常链追踪到异常最初发生的位置。
public class AutoCloseTest{
public static void main(String[] args){
throws IOException
{
try(
//实现工资结算的业务逻辑
catch(SQLException sqle)
{
//把原始异常记录下来，留给管理员
...
//下面异常中的message就是对用户的提示
throw new SalExcetion(sqle);
}
catch(Exception e)
{
//把原始异常记录下来，留个管理员
...
throw new SalException(e);
}
}上面程序中粗体字代码创建SalException对象时，传入了一个Exception对象，而不是传入一个String对象，这就需要SalException类相应的构造器。从1.4以后，Throwable基类已有了一个可以接收Exception参数的方法，所以可以采用SqlException类。
public class SalException extends Exception{
public SalException(){}
public SalException(String msg){
super(msg);
}
//创建一个可以接收Throwable参数的构造器
public SalException(Throwable t)
{
super(t);
}
}Java的异常跟踪栈
异常对象的printStackTrace(）方法用于打印异常的跟踪栈信息，根据printStackTrace()方法的输出结果，开发者可以找到异常的源头，并跟踪到异常一路触发的过程。
异常处理规则
成功的异常处理应遵循以下4个目标
使程序代码混乱最小化
捕获保留诊断信息
通知合适的人员
采用合适的方式结束异常活动
总结
java的异常处理主要依赖于try、catch、finally、throw和throws 5个关键字。应知悉Checked异常和Runtime异常之间的区别，知道实际开发中最常用的异常链和异常转译。
扫一扫
694
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
