精华内容
下载资源
问答
  • try finally没有catch的用法

    千次阅读 2016-12-12 12:01:15
    在Java的trycatchfinally中,try是必须的,catchfinally都不是必须的。 因为捕获异常是必须要有的,而捕获到异常之后,如果不做处理,那就不用写catch,如果需要对捕获到异常之后做处理才需要catchfinally也...
    在Java的try、catch、finally中,try是必须的,catch和finally都不是必须的。
    

    因为捕获异常是必须要有的,而捕获到异常之后,如果不做处理,那就不用写catch,如果需要对捕获到异常之后做处理才需要catch,finally也是一样,可以不用写,也可以加上。

    执行流程是先执行try块,出现异常后执行finally块,最后向调用者抛出try中的异常。这种执行结果是很正常的,因为没有catch异常处理器,所有该方法只能将产生的异常向外抛;因为有finally,所以会在方法返回抛出异常之前,先执行finally代码块中的清理工作。

    那什么时候使用try-finally,什么时候使用try-catch-finally呢?很显然这 取决于方法本身是否能够处理try中出现的异常 。如果自己可以处理,那么直接catch住,不用抛给方法的调用者;如果自己不知道怎么处理,就应该将异常向外抛,能够让调用者知道发生了异常。即在方法的签名中声明throws可能出现而自己又无法处理的异常,但是在方法内部做自己应该的事情。

    展开全文
  • Java-try finally没有catch的用法

    千次阅读 2018-08-09 09:40:57
    JDK并发工具包中,很多异常处理都使用了如下的结构,如AbstractExecutorService,即只有tryfinally没有catch。 class X { private final ReentrantLock lock = new ReentrantLock(); // ... public void m...

    JDK并发工具包中,很多异常处理都使用了如下的结构,如AbstractExecutorService,即只有try和finally没有catch。

    class X 
    {
        private final ReentrantLock lock = new ReentrantLock();
        // ...
     
        public void m()
        {
    	lock.lock();  // block until condition holds
    	try 
    	{
    		// ... method body
    	} finally
    	{
    		lock.unlock()
    	}
         }
    }
    

    为什么要使用这种结构?有什么好处呢?先看下面的代码

     public void testTryAndFinally(String name)
     {
            try
            {
                name.length();// NullPointerException
            }
            finally
            {
                System.out.println("aa");
            }
     }
    

    传递null调用该方法的执行结果是:在控制台打印aa,并抛出NullPointerException。即程序的执行流程是先执行try块,出现异常后执行finally块,最后向调用者抛出try中的异常。这种执行结果是很正常的,因为没有catch异常处理器,所有该方法只能将产生的异常向外抛;因为有finally,所以会在方法返回抛出异常之前,先执行finally代码块中的清理工作。

     

    这种做法的好处是什么呢?对于testTryAndFinally来说,它做了自己必须要做的事(finally),并向外抛出自己无法处理的异常;对于调用者来说,能够感知出现的异常,并可以按照需要进行处理。也就是说这种结构实现了职责的分离,实现了异常处理(throw)与异常清理(finally)的解耦,让不同的方法专注于自己应该做的事。

     

    那什么时候使用try-finally,什么时候使用try-catch-finally呢?很显然这取决于方法本身是否能够处理try中出现的异常。如果自己可以处理,那么直接catch住,不用抛给方法的调用者;如果自己不知道怎么处理,就应该将异常向外抛,能够让调用者知道发生了异常。即在方法的签名中声明throws可能出现而自己又无法处理的异常,但是在方法内部做自己应该的事情。这可以参考ExecutorService.invokeAny()的方法签名

     <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException;
    

     

    展开全文
  • 只有try-finally没有catch的原因(深究)

    千次阅读 2013-03-07 20:57:52
    Q:当读一些源码的时候发现有些情况是只有try-finally没有catch只是什么原因呢? public class Test {   public static void main(String[] args) {  System.out.println(decision());  }  static ...

    Q:当读一些源码的时候发现有些情况是只有try-finally 并没有catch只是什么原因呢?

    public class Test { 
        public static void main(String[] args) {
            System.out.println(decision());
        }
        static boolean decision() {
            try {
                return true;
            } finally {
                return false;
            }
        } 
    }

    你可能会认为这个程序是不合法的。毕竟,decision方法不能同时返回true和false。如果你尝试一下,就会发现它编译时没有任何错误,并且它所打印的是false。为什么呢?
    原因就是在一个try-finally语句中,finally语句块总是在控制权离开try语句块时执行的。无论try语句块是正常结束的,还是意外结束的,情况都是如此。一条语句或一个语句块在它抛出了一个异常,或者对某个封闭型语句执行了一个break或continue,或是象这个程序一样在方法中执行了一个return时,将发生意外结束。它们之所以被称为意外结束,是因为它们阻止程序去按顺序执行下面的语句。

    当try语句块和finally语句块都意外结束时,在try语句块中引发意外结束的原因将被丢弃,而整个try-finally语句意外结束的原因将于finally语句块意外结束的原因相同。在这个程序中,在try语句块中的return语句所引发的意外结束将被丢弃,而try-finally语句意外结束是由finally语句块中的return造成的。简单地讲,程序尝试着(try)返回(return)true,但是它最终(finally)返回(return)的是false。

    丢弃意外结束的原因几乎永远都不是你想要的行为,因为意外结束的最初原因可能对程序的行为来说会显得更重要。对于那些在try语句块中执行break、continue或return语句,只是为了使其行为被finally语句块所否决掉的程序,要理解其行为是特别困难的。

    总之,每一个finally语句块都应该正常结束,除非抛出的是不受检查的异常。千万不要用一个return、break、continue或throw来退出一个finally语句块,并且千万不要允许将一个受检查的异常传播到一个finally语句块之外去。

     try/catch/finally语句下,finally子句是肯定会执行的。但是很多人做不同的测试,却得出了不同的结论。

    具体的原理最好是去看《深入java虚拟机》,里面对jsr、ret等几个指令做了详细的说明。这里不深入分析,而仅仅是从表现形式上看一下finally的特征。

    代码:


    /*

     * author: Zang XT

     */

    public class TestFinal {

        public static void main(String[] args) {

            System.out.println("test1:"+testFinal1());

            System.out.println("test2:"+testFinal2());

            System.out.println("test3:"+testFinal3());

            System.out.println("test4:"+testFinal4());

        }

        static int testFinal1(){

            int i = 1;

            try{

                return i;

            }

            finally{

                System.out.println("in testFinal1():finally 肯定会被执行的!");

                i = 48;

            }

        }

        static String testFinal2(){

            String str = "try";

            try{

                return str;

            }

            finally{

                System.out.println("in testFinal2():finally 肯定会被执行的!");

                str = "finally";

            }

        }

        static StringBuilder testFinal3(){

            StringBuilder build = new StringBuilder("try ");

            try{

                return build;

            }

            finally{

                System.out.println("in testFinal3():finally 肯定会被执行的!");

                build.append("finally");

                build = new StringBuilder("你猜我是谁!");

            }

        }

        static String testFinal4(){

            try{

                return "return in try";

            }

            finally{

                System.out.println("in testFinal4():finally 肯定会被执行的!");

                return "return in finally";

            }

        }

    }


    输出是:

    in testFinal1():finally 肯定会被执行的!

    test1:1

    in testFinal2():finally 肯定会被执行的!

    test2:try

    in testFinal3():finally 肯定会被执行的!

    test3:try finally

    in testFinal4():finally 肯定会被执行的!

    test4:return in finally

    结论很明显,finally的语句确实执行了,而且肯定是在方法return之前执行的,而且,如果finally中有return语句的话,方
    法直接结束。这里需要注意的只有一点:在try中的return语句会将返回结果值压栈,然后转入到finally子过程,等到finally
    子过程执行完毕之后(没有return),再返回。
    下面具体看4个例子:
    在testFinal1()中,return i;会将结果i的值,也就是1压入栈。即使在finally中将i修改了(i=48),也不回对已经压入栈里
    的1造成任何影响。
    在testFinal2()中,return str;将str的内容压入栈,比如我们假设str的内容为0x108(只是一个地址值),通过这个地址值我
    们能找到"try",那栈里的内容就是0x108。执行str = "finally",这时候str这个变量的内容可能变为0x237了,这是
    串"finally"的地址。方法调用结束后,返回的是什么?return时压入栈里的0x108。所以在打印结果时,我们打印的是通过
    0x108找到的字符串"try"。
    在testFinal3()中,return 压栈的是build这个变量的值,比如是0x3579,通过这个值我们可以找到StringBuilder对象。
    finally语句块中对这个对象的内容进行了修改。build = new StringBuilder("你猜我是谁!");让build变量指向了一个新的
    对象,这时候build的值可能是0x4579了。但是,别忘了,原来的StringBuilder对象仍然在0x3579处,而我们压栈的正是
    0x3579啊!方法返回后,我们得到的返回值0x3579,通过这个引用值找到相应的StringBuilder对象,所以打印的结果是
    test3:try finally。
    在testFinal4()中,finally有return语句,直接返回,方法结束。
            为什么不同的人有不同的结论?关键是没有正确理解压栈的是什么东西。其实初学java的时候,如果理解了变量是什
    么,并区分引用和对象本身就不会得到错误的结论了。再有,如果理解java中,方法调用都是采用传值模式的话,这里也就
    类似的可以明白了。


    展开全文
  • 因为没有catch捕获异常,所以异常发生时,会将异常抛出,导致程序中止;在抛出之前会执行finally中的代码。 用于无法捕获处理异常,需要在程序结束之前进行善后处理的场景 转载于:...

    因为没有catch捕获异常,所以异常发生时,会将异常抛出,导致程序中止;在抛出之前会执行finally中的代码。

     

    用于无法捕获处理异常,需要在程序结束之前进行善后处理的场景

    转载于:https://www.cnblogs.com/genggeng/p/10790522.html

    展开全文
  • try catch finally

    2014-01-21 15:34:48
    try+catch+finally try+catch 如果在try语句中捕获到异常,那么进入catch语句块,最后执行catch语句块后面的代码;如果没有捕获到异常,那么catch语句块中的代码将不执行。直接执行catch语句块后的代码 try+catch...
  • Java的 trycatch finally关键字的使用
  • 只用tryfinally而不使用catch的原因: try方法块抛出的异常,catch处理不了(NPE...) public void testTryAndFinally(String name){ try { name.length();// NullPointerException } finally {
  • JDK1.7都发布这么多年了,一直都习惯try-catch-finally,还不知道有try-with-resource这回事,通过这篇文章来了解下try-with-resource的简洁之处。
  • try-catch-finally捕获异常try-catch-finally捕获异常
  • 主要介绍了再谈异常处理try catch finally 的相关资料,需要的朋友可以参考下
  • pb 的try catch finally end try

    千次阅读 2008-11-12 21:48:00
    pb 的try catch finally end try
  • 主要介绍了C#中的try catch finally用法,以实例形式分析了try catch finally针对错误处理时的不同用法,具有一定的参考借鉴价值,需要的朋友可以参考下
  • 为了弄清楚try-finallytry-catch-finally的使用和执行流程,进行了如下实验,先分享给网友们,不对的地方指正批评哈!!! 实验方法:根据try所在的函数是否带返回值、return所在的位置和是否抛出异常三种情况进行...
  • 首先看个例子:public class TestReturn { public int test(){ int x = 1; try{ return ++x; } catch(Exception e){ }finally{ ++x; }
  • C# try catch finally

    千次阅读 2014-01-23 13:36:09
     catchfinally 一起使用的常见方式是:在 try 块中获取并使用资源,在 catch 块中处理异常情况,并在 finally 块中释放资源。 Catch  catch 这将捕获任何发生的异常。  catch(Exception e) 这将捕获...
  • try-catch-finally执行顺序验证(左边是.java文件,右边是.class文件) 提示: trycatch块内的return操作编译后会变成把return的值保存到变量var的操作。 总结: trycatch块内的return操作编译后会变成把return的值...
  • 主要介绍了杂谈try-catch-finally异常处理的相关资料,需要的朋友可以参考下
  • 主要介绍了Java try catch finally异常处理组合详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • JAVA try catch finally return 执行顺序 参考:https://www.cnblogs.com/superFish2016/p/6687549.html 一、结论 1、不管有没有出现异常,finally块中代码都会执行; 2、当trycatch中有return时,finally仍然会...
  • try catch finally 用法

    千次阅读 多人点赞 2018-10-13 19:34:59
     正常情况下,先执行try里面的代码,捕获到异常后执行catch中的代码,最后执行finally中代码,但当在try catch中执行到return时,要判断finally中的代码是否执行,如果没有,应先执行finally中代码再返回。...
  • 首先执行try,如果有异常执行catch,无论如何都会执行finally,当有return以后,函数就会把这个数据存储在某个位置,然后告诉主函数,我不执行了,接下来你执行吧,所以函数就会推出
  • Condition 1: 如果try没有异常且try中有return (执行顺序) try ---- finally --- return11 ...try----catch---finally--- return11 总之 finally 永远执行! Condition 3: try中有异常,try-cat
  • try-catch-finally

    万次阅读 2013-04-16 10:41:53
    要解决那个问题就要明白trycatchfinally的用法了。 1. 为什么要用finally??因为异常进入catch后有时需要直接返回,不继续执行后面的语句,但是还有一部分工作要做(比如释放资源之类的)这时就要写到...
  • @try @catch @finally

    2018-08-04 08:30:23
    @try { ... 逻辑处理 ...执行的代码,其中可能有异常。一旦发现异常,则立即跳到catch执行。否则不会执行catch里面的内容 } ...@catch { ...不管什么情况都会执行,包括try catch 里面用了return ,可以...
  • Java中try catch finally的使用

    万次阅读 多人点赞 2018-07-06 12:44:18
    在Java中提供了try catch finally结构来进行异常处理。大致执行结构如下try{ //代码执行区域 }catch(Exception e){ //异常处理区域 }finally { //无论如何,都会执行的代码块 } 一、执行顺序在java...
  • 本文为大家分析了javascript中trycatchfinally的使用方法,分享给大家供大家参考,具体内容如下 稍微复杂一点点,就要用到判断语句,if else进行条件判断,话说if条件else否则,这样的判断对于写程序代码的码侬...
  • try-catch-finally 中哪个部分可以省略? catchfinally 语句块可以省略其中一个。 package constxiong.interview; public class TestOmitTryCatchFinally { public static void main(String[] args) { ...
  • try catch finally的执行顺序

    千次阅读 2017-11-02 21:39:43
    通过编写一些常见的例子来更深入的理解trycatchfinally的执行顺序,代码如下: import java.util.Scanner; /* * 通过sum函数返回的值来确定return了哪个 * 0:默认返回 * 1:finally的返回值 * 2:通用异常...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 603,274
精华内容 241,309
关键字:

finally没有catchtry