finally的作用到底在模块里的实际应用

finally语句快用来操作一些必须执行的操作，，

如果你看到IO流那里就会知道，它经常用来关闭资源，例如下：

1. import java.io.BufferedReader;
   
2. import java.io.FileWriter;
   
3. import java.io.IOException;
   
4. import java.io.InputStreamReader;
   
5. import java.io.PrintWriter;
   
6. 
   
7. public class PrintDemo {
   
8.         public static void main(String[] args) {
   
9.                 BufferedReader br = null;
   
10.                 PrintWriter pw = null;
    
11.                 try {
    
12.                         br = new BufferedReader(new InputStreamReader(System.in));
    
13.                         pw = new PrintWriter(new FileWriter("d:\\test\\abc.txt"), true);
    
14.                         String line = null;
    
15.                         while ((line = br.readLine()) != null) {
    
16.                                 pw.println(line.toUpperCase());
    
17.                         }
    
18. 
    
19.                 } catch (IOException e) {
    
20.                         e.printStackTrace();
    
21.                 } finally {
    
22.                         try {
    
23.                                 if (br != null)
    
24.                                         br.close();
    
25.                         } catch (IOException e) {
    
26.                                 e.printStackTrace();
    
27.                         } finally {
    
28.                                 if (pw != null)
    
29.                                         pw.close();
    
30. 
    
31.                         }
    
32.                 }
    
33. 
    
34.         }
    
35. }

复制代码

这个例子就是用finally语句快关闭IO的输入输出资源，不论是否发生异常关闭资源都是必须做的；

一般用在 数据库的 关闭   因为如果没有finally 这一步  就是意味着有可能 资源 一直在占着    你不关闭别人想用用不上    存在资源的浪费

finnally代码块中代码是无论发生什么事都必须执行的。常用作释放资源（电脑的内存资源，不然内存泄露，容易卡死电脑。）  就说，就算有异常，代码给挂了。也必须把该释放的资源给释放了。很多链接的关闭常常用到。因为链接占用着电脑的内存，不释放内存浪费着，浪费多了，就卡了。 像关闭文件流，关闭数据库连接是很常用的，因为都占着电脑内存的。

package cn.itcast_04;

/*
* 作为异常处理来说，最标准的格式：
* try{
*                 可能有问题的代码;
* }catch(){
*                 代码的处理方案;
* }finally{
*                 一定会执行的代码;
*                 一般放置的是释放资源的代码。
* }
*
* 学到数据了：
* try{
*                 数据库的连接
*                 数据库的操作
* }catch(){
*                 数据库的异常处理
* }finally{
*                 数据库的关闭
* }
*
* finally比较特殊：里面的代码永远会执行。
* 特殊情况：在执行到finally里面的代码之前，退出了jvm。
*/
public class FinallyDemo {
        public static void main(String[] args) {
                int a = 10;
                int b = 0;
                try {
                        System.out.println(a / b);
                } catch (ArithmeticException e) {
                        e.printStackTrace();
//                        System.exit(0);//退出了jvm
                } finally {
                        System.out.println("haha");
                        System.out.println("hehe");
                }
        }
}
亲，你可以借鉴下！

当我们在程序中需要与文件,与数据库进行操作的时候.这时候finally关键字就是大显身手的时刻了.比如:当打开一个文件后,在程序操作的过程中可能发生了某种异常,这时候程序就会把异常向外抛出,造成程序的中断执行,因此我们已经无法对文件进行关闭.当在try的结束位置加上finally,可以把文件关闭的操作放在finally语句块中.这样无论发生不发生异常,finally中的代码都会被执行,这就避免了文件可能没有被关闭的情况. try { //可能发生异常的代码 }catch(Exception e) { //捕获异常 }finally { //必要的操作,无论异常是否发生,都会被执行 } 尤其是在操作数据库的时候,如果不用finally,那么一旦发生异常,连接就无法关闭,会造成数据库的连接资源耗尽..有请大牛们

1.当try里面的代码没有异常的时候，会执行该try块对应的finally块，并继续执行finally之后的代码。

2。当try里面的代码出现异常的时候，会执行该try块对应的catch块和finally块，且即使catch中有返回finally也是要执行。也就是先执行完finally中的语句，再返回catch中的return。

3。finally中如果有return的情况，那么即使catch中有return，这个return也不起作用，该方法调用要到finally中的return才返回。
4.在排错中使用finally能够清晰的找到错误的原因。

应该是为了保证资源的节省吧，用在数据库的关闭上，如果程序出现问题 ，有一个finally来关闭数据库是不是相对来说更好一些嘛！就像人要负责任一样嘛！我打开后，用了再关，用不了也是要关的，要不然岂不是浪费了！