........................
java中的异常、断言、日志(一)
上一篇 / 下一篇 2016-05-24 14:12:38 / 个人分类：接口测试
1.Java异常处理
i.异常的概念和Java里面的异常体系结构
1)基本概念：
程序中的异常，一般成为例外情况，可以理解为是非正常情况，其他编程语言里面也有这样的情况，Java里面同样存在这样一个体系结构，这里需要分清楚的是异常和错误不是一个概念。异常并非是真正的错误，因为他们是一些例外情况，这些情况有可能不会导致系统直接崩溃掉，但是它的存在只能说是程序的某种缺陷，或者说是非必然缺陷，而Java里面提供的异常体系结构就是为了解决这些缺陷而存在的。
在异常处理机制诞生之前，传统的异常处理方式多数是为了采用返回值来标识程序出现异常的情况，这种方式都很熟悉，如同在调试过程即是有良好的调试工具，但是常用的手段就是System.out.println的方式，但是这样的方式隐含一定的缺点。
[1]一个API可以返回任意的值，但是这些返回值本身不能解释返回值是否代表一个异常发生了，也不能描述异常的详细情况，若要知道该API出现异常的一些内容，还需要调用它的某些方法；
[2]没有一种结构可以确保异常情况能够得到处理，如果使用第一种方法，就会使得代码的可读性很差，而且很多时候并不能因为某些情况的存在就终止程序，就程序本身而言是应该提供一定的反馈情况。假设这样一个场景，如果你去输入用户名和密码登陆，如果你的用户名和密码输入错误了，但是界面上没有任何反应，这种情况是不是很糟糕，当然这只是个比方，这里不一定是出现了异常。
在开发过程中，当一个程序本身抛出了异常过后，程序会从程序导致异常的地方跳出来，在java语言里面，使用try和catch块来实现，当JVM碰到这个语句块的时候，它会监听整个Java程序，一旦出现了任何异常情况，它会将整个程序的执行权交给catch块来执行。
先看一段简单的代码：
import java.io.File;
import java.io.FileReader;
/**
*一个简单的文件操作
**/
public class CustomerFileReader
{
public static void main(String args[])
{
File file = new File("C:/read.txt");
FileReader reader = new FileReader(file); //这句话不能通过JVM的编译器
}
}
上边这段代码如果使用的是javac的命令，那么编译器就会报错，可能错误信息如下：
unreported exception java.io.FileNotFoundException; must be caught or declared to be thrown
那么如果要保证上边这句代码是能够通过编译的，如何简单修改呢，有两种方式：
[1]加入try和catch块，使用JVM的异常体系结构去捕捉该异常；
[2]直接throws这个异常，让程序显式抛出该异常
2)Java里面的异常体系结构：
先看下边的异常体系结构图：
Java里面的异常分类按照下边的结构来分：
Throwable是所有异常的基类，程序中一般不会直接抛出Throwable对象，Throwable本身存在两个子类实例，一个是Error、一个是Exception；
[1]Error：在Java里面Error表示程序在运行期间出现了十分严重的问题以及不可以恢复的错误，这种情况唯一的办法是中止程序运行，JVM一般不会检查Error是否被处理，而本身在程序中也不能捕获Error类型的异常，因为Error一旦产生，该程序基本会处于需要中止的状态。
[2]Exception：在Java里面Exception指的就是在编程过程可能会遇到的异常的概念，也属于Java程序里面允许出现的例外的状况，而Exception本身分为以下两种：
RuntimeException：该异常继承于Exception类，这种类型的异常可以这样理解，为不可估计的异常，一般称为运行时异常，从字面意思上讲就是在程序正式运行的时候会碰到的偶发性异常，这种异常因为是在运行时抛出一般情况下不需要进行捕获操作。
CheckedException：该类异常不存在继承于Exception类的说法，因为Java里面没有CheckedException异常类，而之所以这样区分，因为CheckedException类的异常是在编程过程中经常会遇到的异常，可以翻译为“可检测异常”或者“捕获型异常”，该类异常往往属于编译期异常，一般开发过程会针对系统进行CheckedException的设计。
【*：JVM在处理Java程序的时候，Runtime Exception和Checked Exception两种类型的异常在运行机制上是不一样的，而仔细考虑两种异常的使用场合也会发现，其两种异常在设计上所提及的使用目的也大相径庭。从程序开发角度可以这样理解：Checked Exception的设计目的在于这个Exception是必须被处理的，在程序设计过程应该知道这类异常会出现，所以要针对这一类型的异常进行不同的处理操作，这些异常也可以认为是在程序设计之初可以考虑到的异常；而RuntimeException可能理解起来隐晦一点，不能说不能考虑到这种异常的存在，反而是即使能够考虑到，也不能进行良性的程序处理，它往往是暗示着程序可能会出现某种错误，这种错误有可能根程序本身无关，也有可能有关，是在设计程序之初是无法预知处理方式的，而有时候甚至会造成程序中止的情况。】
这里提供一个简单的关于RuntimeException的例子：
public class RunExpTester
{
public static void main(String args[])
{
try
{
//……
}
catch(Exception ex)
{
//……
}
}
}
考虑一下上边这段代码，上边这段代码使用了面对CheckedException的程序处理方式，使用了try和catch块来处理有可能存在的Exception，但是这样就出现了一个缺点：很可能不知道发生了什么异常，这些异常的源头，而且如果整个程序段里面还包含了必须处理的CheckedException，那么这种设计方法反而给开发带来了不必要的成本开销。
一般情况下，在测试阶段，如果遇到了RuntimeException可以让它这样存在或者发生，然后再逐渐去修改的代码，让它尽量避免掉，否则面对任何一个Exception，都要确定不会轻易出现或者说更加完美一定不出现RuntimeException为之。这里提供一个常用的编程习惯作为参考，在使用Exception的catch过程的时候，一般可以这样来书写：
catch(Exception ex)
{
// TODO：书写该异常的说明
ex.printStackTrace();
}
当然这种情况是使用IDE的时候的一种习惯，一般IDE都提供了TODO：标记，使用该标记和所有TaskList的前缀标记不仅仅可以在开发过程了解到底有多少地方存在手写的异常，而且在针对CheckedException的处理过程中，不是每一个异常都需要使用ex.printStackTrace()方法将该异常的堆栈信息全部打印出来，有时候需要在catch块里面书写更加实用的异常处理代码。
3)深入了解Throwable类：【参考API文档】
Throwable类是Java语言中所有错误（Error）或异常（Exception）的超类，只有当某个对象是该类的子类实例的时候，才能通过JVM或者Java本身编写过程的throw语句抛出，按照这种逻辑区判断，只有此类或者它的子类才可以是catch子句中的参数类型。Throwable类有两个子类Error和Exception，上边已经简单介绍过这两种类型的区别了。Throwable类本身包含：
[1]线程创建的时候执行堆栈的快照
[2]有关错误的消息字符串，比如该异常出现的位置以及代码里面的哪一行
[3]它指出了这个异常的原因：该异常是由哪个异常导致的或者说是由哪个异常抛出的Throwable导致的这个Throwable的产生
从JDK 1.4开始，出现了一个异常处理的新概念：异常链(Cause机制)。异常链机制可以这样理解：如果某个程序出现了异常，那么该异常本身也会有个原因，这个原因可能是自身的，也可能是外界的，以此类推就形成了一个异常链，简单讲：每个异常都是由另外一个异常引起的。
而什么内容导致了throwable cause呢，查阅官方的API文档有以下两种解释：
[1]导致throwable cause的一个理由是，抛出它的类构建在低层抽象之中，而高层操作由于低层操作的失败而失败。让低层抛出的throwable向外传播是一种糟糕的设计方法，因为它通常与高层提供的抽象不相关。此外，这样做将高层API与其实现细节关联起来，假定低层异常是经过检查的异常。抛出“经过包装的异常”（即包含cause的异常）允许高层与其调用方交流失败详细信息，而不会招致上述任何一个缺点。这种方式保留了改变高层实现而不改变其 API 的灵活性
[2]导致throwable cause的另一个cause是，抛出它的方法必须符合通用接口，而通用接口不允许方法直接抛出cause。例如，假定持久集合符合Collection接口，而其持久性在java.io的基础上实现。假定add方法的内部可以抛出IOException。实现可以与其调用方交流IOException的详细消息，同时通过以一种合适的未检查的异常来包装IOException，使其符合Collection接口。
4)特殊类AssertionError：
这里提供一段代码：
public class AssertionErrorTester
{
public static void main(String args[])
{
try
{
assert args.length < 0:"Args Length Error!";
}
catch(AssertionError e)
{
String message = e.getMessage();
System.out.println("Error Source:" + message);
}
}
}
【*：这里需要提及的一个异常类是AssertionError类，因为上边已经讲过了，所有的Error都是不能进行catch的处理的，但是AssertionError属于一个比较特殊的类，因为JVM针对AssertionError类是可以进行catch处理的，该Error和普通的Error可能存在本质的区别】
使用断言编译方式编译以上代码，然后打开断言执行该编译好的class文件，会出现以下输出：
Error Source:Args Length Error!
关于如何使用断言编译以及断言本身的使用规则在断言章节会涉及到，这里先不做详细讲解
ii.异常的基本语法
前边介绍了Java异常体系结构、分类以及基本概念，这一小节需要介绍的就是Java里面异常的基本语法。在Java里面，异常处理机制的编程部分需要使用到几个关键字：try、catch、finally、throw、throws
1)try、catch、finally关键字：
/**
*测试Exception关键字的代码
**/
public class ExceptionTester
{
public static void main(String args[])
{
//这一块被成为异常的正常执行块，也就是如果没有异常抛出的话，try块会一直这样正常执行到最末位
try
{
//判断输入参数的长度
if( args.length == 0 )
{
System.out.println("Args length is zore");
}else{
String inputString = args[0];
int inputNumber = Integer.parseInteger(inputString);
System.out.println("Input number is " + inputNumber);
}
}
//这一块是异常处理块，一旦当try代码块里面抛出了异常的时候，直接从try块中断，直接进行catch代码块的执行
catch(Exception ex)
{
ex.printStackTrace();
}
//finally代码块，不论try中是否抛出异常，也不论catch里面是否真正能够捕捉到异常，finally里面的代码都会执行（有例外）
finally
{
System.out.println("Testing finishing...");
}
}
}
这段代码出现了三个关键字，try、catch、finally，这里先对这三个关键字简单讲解：
try语句：
该语句块属于代码的正常执行块，如果这段代码里面不会出现任何异常，那么try语句块会按照顺序一直执行下去
catch语句：
该语句块的参数类似于平时在代码书写中的方法声明，包含了一个异常类型以及一个异常对象。这里结合第一节讲到的，异常类型必须是Throwable的子类型，它指出了catch语句处理的异常类型，异常对象则有可能在try语句块里面生成，而且被对应的catch块里面的异常类型所捕获，大括号里面的内容就是当你捕获了对应的异常过后如何进行处理。
在异常处理里面，catch语句块可以有多个，分别处理不同的异常。Java运行的时候一旦抛出了异常就从catch块从上往下检索，一旦匹配对应的类型就执行catch块里面的内容，所以这里有一点需要注意：
catch块里面的异常类型的顺序，一般情况是从特殊到一般，然后是从子类到父类，否则会造成代码不可达的无用代码块
finally语句：
该语句块可以指定一个段代码块，不论try块也好、catch块也好，也不论异常是否抛出，最终都会执行finally块里面的内容，可以这样理解：finally块里面是异常处理机制的统一出口，只要存在这样的一段代码块最终出口都是执行完finally块里面的内容了再继续。【*：但是有一个特殊的情况，如果try块里面出现了return语句，那么finally块里面的内容是不会执行的，但是这种做法不提倡。】
2)throw、throws关键字：
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
/**
*提供throw和throws关键字的代码块
**/
public class ThrowInstance
{
public static void main(String args[]) throws Exception
{
try
{
readFile("C:/read.txt");
}
catch(IOException ex)
{
throw new Exception(ex);
}
}
public static void readFile(String path) throws IOException
{
File file = new File(path);
FileReader reader = new FileReader(file);
}
}
从上边这段代码理解throw和throws关键字：
throw关键字：
throw关键字总是出现在函数体内部，用来抛出一个异常，程序会在throw语句后立即终止执行，也就是说位于throw语句之后的语句块不会执行，一旦它抛出了一个异常过后，JVM会在包含它的try块所对应的catch里面根据抛出的异常类型匹配操作，如果能匹配就直接被捕捉，一旦不能匹配就继续往执行体的外层抛出该异常。
throws关键字：
throws关键字总是出现在函数头部，用来表明该函数有可能会抛出某种异常，有几点需要注意：
[1]函数可以抛出多个不同类型的异常，直接使用，将每种抛出的不同异常分开；
[2]如果函数体里面存在throw语句，而且函数体本身没有进行捕捉的话，那么必须使用throws在函数头里面添加对应的异常抛出语句，否则无法通过编译
[3]如果编写代码的时候需要明确抛出一个RuntimeException，那么必须显示使用throws语句来声明它的类型
[4]以上的规则主要是针对CheckedException，针对Error和RuntimeException或者它们的子类，这些规则不起作用
3)关键字的搭配：
try+catch：
这是常用的代码结构，这种情况类似下边这种情况：
/**
*try+catch语句块
**/
public class TryCatch
{
public static void main(String args[])
{
try
{
//正常执行语句块
}
catch(Exception ex)
{
//抛出异常过后的异常捕捉语句块，捕捉到异常了就执行
}
}
}
这种语句块的执行流程为：运行try块中的代码，如果有异常抛出，就会转到catch语句块中执行，当然前提是catch中的异常类型和try块中抛出的异常类型匹配。
try+catch+finally
/**
*try+catch+finally语句块
**/
public class TryCatch
{
public static void main(String args[])
{
try
{
//正常执行语句块
i.异常的概念和Java里面的异常体系结构
1)基本概念：
程序中的异常，一般成为例外情况，可以理解为是非正常情况，其他编程语言里面也有这样的情况，Java里面同样存在这样一个体系结构，这里需要分清楚的是异常和错误不是一个概念。异常并非是真正的错误，因为他们是一些例外情况，这些情况有可能不会导致系统直接崩溃掉，但是它的存在只能说是程序的某种缺陷，或者说是非必然缺陷，而Java里面提供的异常体系结构就是为了解决这些缺陷而存在的。
在异常处理机制诞生之前，传统的异常处理方式多数是为了采用返回值来标识程序出现异常的情况，这种方式都很熟悉，如同在调试过程即是有良好的调试工具，但是常用的手段就是System.out.println的方式，但是这样的方式隐含一定的缺点。
[1]一个API可以返回任意的值，但是这些返回值本身不能解释返回值是否代表一个异常发生了，也不能描述异常的详细情况，若要知道该API出现异常的一些内容，还需要调用它的某些方法；
[2]没有一种结构可以确保异常情况能够得到处理，如果使用第一种方法，就会使得代码的可读性很差，而且很多时候并不能因为某些情况的存在就终止程序，就程序本身而言是应该提供一定的反馈情况。假设这样一个场景，如果你去输入用户名和密码登陆，如果你的用户名和密码输入错误了，但是界面上没有任何反应，这种情况是不是很糟糕，当然这只是个比方，这里不一定是出现了异常。
在开发过程中，当一个程序本身抛出了异常过后，程序会从程序导致异常的地方跳出来，在java语言里面，使用try和catch块来实现，当JVM碰到这个语句块的时候，它会监听整个Java程序，一旦出现了任何异常情况，它会将整个程序的执行权交给catch块来执行。
先看一段简单的代码：
import java.io.File;
import java.io.FileReader;
/**
*一个简单的文件操作
**/
public class CustomerFileReader
{
public static void main(String args[])
{
File file = new File("C:/read.txt");
FileReader reader = new FileReader(file); //这句话不能通过JVM的编译器
}
}
上边这段代码如果使用的是javac的命令，那么编译器就会报错，可能错误信息如下：
unreported exception java.io.FileNotFoundException; must be caught or declared to be thrown
那么如果要保证上边这句代码是能够通过编译的，如何简单修改呢，有两种方式：
[1]加入try和catch块，使用JVM的异常体系结构去捕捉该异常；
[2]直接throws这个异常，让程序显式抛出该异常
2)Java里面的异常体系结构：
先看下边的异常体系结构图：
Java里面的异常分类按照下边的结构来分：
Throwable是所有异常的基类，程序中一般不会直接抛出Throwable对象，Throwable本身存在两个子类实例，一个是Error、一个是Exception；
[1]Error：在Java里面Error表示程序在运行期间出现了十分严重的问题以及不可以恢复的错误，这种情况唯一的办法是中止程序运行，JVM一般不会检查Error是否被处理，而本身在程序中也不能捕获Error类型的异常，因为Error一旦产生，该程序基本会处于需要中止的状态。
[2]Exception：在Java里面Exception指的就是在编程过程可能会遇到的异常的概念，也属于Java程序里面允许出现的例外的状况，而Exception本身分为以下两种：
RuntimeException：该异常继承于Exception类，这种类型的异常可以这样理解，为不可估计的异常，一般称为运行时异常，从字面意思上讲就是在程序正式运行的时候会碰到的偶发性异常，这种异常因为是在运行时抛出一般情况下不需要进行捕获操作。
CheckedException：该类异常不存在继承于Exception类的说法，因为Java里面没有CheckedException异常类，而之所以这样区分，因为CheckedException类的异常是在编程过程中经常会遇到的异常，可以翻译为“可检测异常”或者“捕获型异常”，该类异常往往属于编译期异常，一般开发过程会针对系统进行CheckedException的设计。
【*：JVM在处理Java程序的时候，Runtime Exception和Checked Exception两种类型的异常在运行机制上是不一样的，而仔细考虑两种异常的使用场合也会发现，其两种异常在设计上所提及的使用目的也大相径庭。从程序开发角度可以这样理解：Checked Exception的设计目的在于这个Exception是必须被处理的，在程序设计过程应该知道这类异常会出现，所以要针对这一类型的异常进行不同的处理操作，这些异常也可以认为是在程序设计之初可以考虑到的异常；而RuntimeException可能理解起来隐晦一点，不能说不能考虑到这种异常的存在，反而是即使能够考虑到，也不能进行良性的程序处理，它往往是暗示着程序可能会出现某种错误，这种错误有可能根程序本身无关，也有可能有关，是在设计程序之初是无法预知处理方式的，而有时候甚至会造成程序中止的情况。】
这里提供一个简单的关于RuntimeException的例子：
public class RunExpTester
{
public static void main(String args[])
{
try
{
//……
}
catch(Exception ex)
{
//……
}
}
}
考虑一下上边这段代码，上边这段代码使用了面对CheckedException的程序处理方式，使用了try和catch块来处理有可能存在的Exception，但是这样就出现了一个缺点：很可能不知道发生了什么异常，这些异常的源头，而且如果整个程序段里面还包含了必须处理的CheckedException，那么这种设计方法反而给开发带来了不必要的成本开销。
一般情况下，在测试阶段，如果遇到了RuntimeException可以让它这样存在或者发生，然后再逐渐去修改的代码，让它尽量避免掉，否则面对任何一个Exception，都要确定不会轻易出现或者说更加完美一定不出现RuntimeException为之。这里提供一个常用的编程习惯作为参考，在使用Exception的catch过程的时候，一般可以这样来书写：
catch(Exception ex)
{
// TODO：书写该异常的说明
ex.printStackTrace();
}
当然这种情况是使用IDE的时候的一种习惯，一般IDE都提供了TODO：标记，使用该标记和所有TaskList的前缀标记不仅仅可以在开发过程了解到底有多少地方存在手写的异常，而且在针对CheckedException的处理过程中，不是每一个异常都需要使用ex.printStackTrace()方法将该异常的堆栈信息全部打印出来，有时候需要在catch块里面书写更加实用的异常处理代码。
3)深入了解Throwable类：【参考API文档】
Throwable类是Java语言中所有错误（Error）或异常（Exception）的超类，只有当某个对象是该类的子类实例的时候，才能通过JVM或者Java本身编写过程的throw语句抛出，按照这种逻辑区判断，只有此类或者它的子类才可以是catch子句中的参数类型。Throwable类有两个子类Error和Exception，上边已经简单介绍过这两种类型的区别了。Throwable类本身包含：
[1]线程创建的时候执行堆栈的快照
[2]有关错误的消息字符串，比如该异常出现的位置以及代码里面的哪一行
[3]它指出了这个异常的原因：该异常是由哪个异常导致的或者说是由哪个异常抛出的Throwable导致的这个Throwable的产生
从JDK 1.4开始，出现了一个异常处理的新概念：异常链(Cause机制)。异常链机制可以这样理解：如果某个程序出现了异常，那么该异常本身也会有个原因，这个原因可能是自身的，也可能是外界的，以此类推就形成了一个异常链，简单讲：每个异常都是由另外一个异常引起的。
而什么内容导致了throwable cause呢，查阅官方的API文档有以下两种解释：
[1]导致throwable cause的一个理由是，抛出它的类构建在低层抽象之中，而高层操作由于低层操作的失败而失败。让低层抛出的throwable向外传播是一种糟糕的设计方法，因为它通常与高层提供的抽象不相关。此外，这样做将高层API与其实现细节关联起来，假定低层异常是经过检查的异常。抛出“经过包装的异常”（即包含cause的异常）允许高层与其调用方交流失败详细信息，而不会招致上述任何一个缺点。这种方式保留了改变高层实现而不改变其 API 的灵活性
[2]导致throwable cause的另一个cause是，抛出它的方法必须符合通用接口，而通用接口不允许方法直接抛出cause。例如，假定持久集合符合Collection接口，而其持久性在java.io的基础上实现。假定add方法的内部可以抛出IOException。实现可以与其调用方交流IOException的详细消息，同时通过以一种合适的未检查的异常来包装IOException，使其符合Collection接口。
4)特殊类AssertionError：
这里提供一段代码：
public class AssertionErrorTester
{
public static void main(String args[])
{
try
{
assert args.length < 0:"Args Length Error!";
}
catch(AssertionError e)
{
String message = e.getMessage();
System.out.println("Error Source:" + message);
}
}
}
【*：这里需要提及的一个异常类是AssertionError类，因为上边已经讲过了，所有的Error都是不能进行catch的处理的，但是AssertionError属于一个比较特殊的类，因为JVM针对AssertionError类是可以进行catch处理的，该Error和普通的Error可能存在本质的区别】
使用断言编译方式编译以上代码，然后打开断言执行该编译好的class文件，会出现以下输出：
Error Source:Args Length Error!
关于如何使用断言编译以及断言本身的使用规则在断言章节会涉及到，这里先不做详细讲解
ii.异常的基本语法
前边介绍了Java异常体系结构、分类以及基本概念，这一小节需要介绍的就是Java里面异常的基本语法。在Java里面，异常处理机制的编程部分需要使用到几个关键字：try、catch、finally、throw、throws
1)try、catch、finally关键字：
/**
*测试Exception关键字的代码
**/
public class ExceptionTester
{
public static void main(String args[])
{
//这一块被成为异常的正常执行块，也就是如果没有异常抛出的话，try块会一直这样正常执行到最末位
try
{
//判断输入参数的长度
if( args.length == 0 )
{
System.out.println("Args length is zore");
}else{
String inputString = args[0];
int inputNumber = Integer.parseInteger(inputString);
System.out.println("Input number is " + inputNumber);
}
}
//这一块是异常处理块，一旦当try代码块里面抛出了异常的时候，直接从try块中断，直接进行catch代码块的执行
catch(Exception ex)
{
ex.printStackTrace();
}
//finally代码块，不论try中是否抛出异常，也不论catch里面是否真正能够捕捉到异常，finally里面的代码都会执行（有例外）
finally
{
System.out.println("Testing finishing...");
}
}
}
这段代码出现了三个关键字，try、catch、finally，这里先对这三个关键字简单讲解：
try语句：
该语句块属于代码的正常执行块，如果这段代码里面不会出现任何异常，那么try语句块会按照顺序一直执行下去
catch语句：
该语句块的参数类似于平时在代码书写中的方法声明，包含了一个异常类型以及一个异常对象。这里结合第一节讲到的，异常类型必须是Throwable的子类型，它指出了catch语句处理的异常类型，异常对象则有可能在try语句块里面生成，而且被对应的catch块里面的异常类型所捕获，大括号里面的内容就是当你捕获了对应的异常过后如何进行处理。
在异常处理里面，catch语句块可以有多个，分别处理不同的异常。Java运行的时候一旦抛出了异常就从catch块从上往下检索，一旦匹配对应的类型就执行catch块里面的内容，所以这里有一点需要注意：
catch块里面的异常类型的顺序，一般情况是从特殊到一般，然后是从子类到父类，否则会造成代码不可达的无用代码块
finally语句：
该语句块可以指定一个段代码块，不论try块也好、catch块也好，也不论异常是否抛出，最终都会执行finally块里面的内容，可以这样理解：finally块里面是异常处理机制的统一出口，只要存在这样的一段代码块最终出口都是执行完finally块里面的内容了再继续。【*：但是有一个特殊的情况，如果try块里面出现了return语句，那么finally块里面的内容是不会执行的，但是这种做法不提倡。】
2)throw、throws关键字：
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
/**
*提供throw和throws关键字的代码块
**/
public class ThrowInstance
{
public static void main(String args[]) throws Exception
{
try
{
readFile("C:/read.txt");
}
catch(IOException ex)
{
throw new Exception(ex);
}
}
public static void readFile(String path) throws IOException
{
File file = new File(path);
FileReader reader = new FileReader(file);
}
}
从上边这段代码理解throw和throws关键字：
throw关键字：
throw关键字总是出现在函数体内部，用来抛出一个异常，程序会在throw语句后立即终止执行，也就是说位于throw语句之后的语句块不会执行，一旦它抛出了一个异常过后，JVM会在包含它的try块所对应的catch里面根据抛出的异常类型匹配操作，如果能匹配就直接被捕捉，一旦不能匹配就继续往执行体的外层抛出该异常。
throws关键字：
throws关键字总是出现在函数头部，用来表明该函数有可能会抛出某种异常，有几点需要注意：
[1]函数可以抛出多个不同类型的异常，直接使用，将每种抛出的不同异常分开；
[2]如果函数体里面存在throw语句，而且函数体本身没有进行捕捉的话，那么必须使用throws在函数头里面添加对应的异常抛出语句，否则无法通过编译
[3]如果编写代码的时候需要明确抛出一个RuntimeException，那么必须显示使用throws语句来声明它的类型
[4]以上的规则主要是针对CheckedException，针对Error和RuntimeException或者它们的子类，这些规则不起作用
3)关键字的搭配：
try+catch：
这是常用的代码结构，这种情况类似下边这种情况：
/**
*try+catch语句块
**/
public class TryCatch
{
public static void main(String args[])
{
try
{
//正常执行语句块
}
catch(Exception ex)
{
//抛出异常过后的异常捕捉语句块，捕捉到异常了就执行
}
}
}
这种语句块的执行流程为：运行try块中的代码，如果有异常抛出，就会转到catch语句块中执行，当然前提是catch中的异常类型和try块中抛出的异常类型匹配。
try+catch+finally
/**
*try+catch+finally语句块
**/
public class TryCatch
{
public static void main(String args[])
{
try
{
//正常执行语句块
相关阅读:
- Java值类型和引用类型的不同之处 (zaza9084, 2016-5-31)
- 深入理解Java中的ArrayList和LinkedList (zaza9084, 2016-5-17)
- Java基础知识总结 (klv091, 2016-5-17)
- 千回百折：百度Java研发offer斩获记和经验分享 (zaza9084, 2016-5-18)
- Java以文本框中设定时间差为单位变化 (zaza9084, 2016-5-19)
- 基于java的selenium webdriver 封装 (快乐逍遥, 2016-5-19)
- 基于java的selenium webdriver 封装 (快乐逍遥, 2016-5-19)
- Java：Json与其他Java对象集合的转换 (zaza9084, 2016-5-20)
- JAVA中List与Set、Map的区别 (zaza9084, 2016-5-23)
- Java8集合中的Lambda表达式 (zaza9084, 2016-5-24)
TAG: java
