精华内容
下载资源
问答
  • java try没有catch

    千次阅读 2018-06-13 10:44:05
    JDK并发工具包中,很多异常处理都使用了如下的结构,如AbstractExecutorService,即只有try和finally没有catch。 [java] view plain copy print?class X   { &...

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

    1. class X   
    2. {  
    3.     private final ReentrantLock lock = new ReentrantLock();  
    4.     // …  
    5.    
    6.     public void m()  
    7.     {  
    8.     lock.lock();  // block until condition holds  
    9.     try   
    10.     {  
    11.         // … method body  
    12.     } finally  
    13.     {  
    14.         lock.unlock()  
    15.     }  
    16.      }  
    17. }  
    class X 
    {
        private final ReentrantLock lock = new ReentrantLock();
        // ...
    
        public void m()
        {
        lock.lock();  // block until condition holds
        try 
        {
            // ... method body
        } finally
        {
            lock.unlock()
        }
         }
    }


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

    1. public void testTryAndFinally(String name)  
    2. {  
    3.        try  
    4.        {  
    5.            name.length();// NullPointerException  
    6.        }  
    7.        finally  
    8.        {  
    9.            System.out.println(”aa”);  
    10.        }  
    11. }  
     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()的方法签名

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


            <link rel="stylesheet" href="https://csdnimg.cn/release/phoenix/template/css/markdown_views-ea0013b516.css">
                </div>
    
    展开全文
  • 主要介绍了c++中try catch的用法小结,需要的朋友可以参考下
  • Java 中 try-catch,throw和throws的使用

    千次阅读 多人点赞 2019-09-21 14:29:19
    关于异常的处理有try catch 程序块、throw 、throws。 以下分别对这三种进行介绍。 一、try...catch try-catch用来捕获代码段的异常并做出处理 try-catch代码块分两块,第一块是try{} ,第二块是catch(exception...

    Java 中的异常有很多,这种异常机制,可以帮助处理程序中未知的错误。关于异常的处理有try catch 程序块、throw 、throws。

    以下分别对这三种进行介绍。

    一、try...catch

    try-catch用来捕获代码段的异常并做出处理

    try-catch代码块分两块,第一块是try{} ,第二块是catch(exception的引用){}。

    try-catch一般放在循环放外。

    try-catch,try即尝试,尝试能不能正常的走完整个作用域,如果不能则抛出一个异常。所以在try块里经常放上可能会抛出异常的程序段。而catch就是处理try里抛出来的异常,其中catch的参数列表接收的是一个异常的引用,是throw抛出来的异常的引用。
    try-catch可以嵌套使用,以下是一个try-catch嵌套使用的例子:

    public static void main(String[] args) {
            try {
                System.out.println("**********************外层try**********************");
                errorMethod();
            } catch (Exception e) {
                System.out.println("**********************外层catch" + e + "**********************");
            } finally {
                System.out.println("**********************外层finally**********************");
            }
        }
     
        private static void errorMethod() {
            try {
                System.out.println("**********************内层try**********************");
                int i = 0;
                int a = 100 / i;
            } catch (Exception e) {
                System.out.println("**********************内层catch" + e + "**********************");
            } finally {
                System.out.println("**********************内层finally**********************");
            }
        }

    内层函数体用零作被除数,报ArithmeticException

    若是注释掉内层catch,其他一样:

    private static void errorMethod() {
            try {
                System.out.println("**********************内层try**********************");
                int i = 0;
                int a = 100 / i;
            } /*catch (Exception e) {
                System.out.println("**********************内层catch" + e + "**********************");
            }*/ finally {
                System.out.println("**********************内层finally**********************");
            }
        }

     

    运行结果是:

    总结一个报错后的执行顺序:

        try {
                //A  报错地方
                try {
                    //B 
                } catch (Exception e) {
                    //C  
                } finally {
                    //D  
                }
                //E  
            } catch (Exception e) {
                //F
            } finally {
                //G
            }

    执行顺序:

    • 内层A,E处抛出异常:由外层catch块捕获,并执行外层finally  ;
    • 内层B处抛出异常,且有一合适内层catch捕获在:执行内层finally,后执行E处  ;
    • 内层B处抛出异常,但内层catch块没有合适处理程序:执行内层finally,搜索外层catch,找合适的,执行外层finally,此时不会执行E  ;
    • 内层C处抛出异常在:退出内层catch块,执行内层finally,搜索外层catch,找到合适,执行外层finally  ;
    • 内层D处抛出异常在:退出内层finally块,搜索外层catch,找到合适,执行外层finally  

    总结:   

    1.try-catch 嵌套内层catch 可以捕获异常时,外层catch不会执行,但finally (多用于IO关闭)都会执行。

    2.try-catch一般用在最上层的程序里,可以配合throws和throw再将异常抛给用户,这种情况会使上层代码中断。也可以不选择抛出,这种上层代码会继续运行。

    3.被调用的方法如果有异常的可能可以通过throws抛给上层处理,不加try catch的情况如下会自动往上抛,加了try catch需要如上通过throw抛给上层程序

    二、throw

    throw 即抛出一个异常,并获取这个异常的引用,这个异常会被抛到外部的环境,由外部环境进行处理。

    throw 一般会用于程序出现某种逻辑时程序员主动抛出某种特定类型的异常。

    class A{
        public void func() throws Exception{
            throw new Exception();
        }
    }

    这里抛出了一个Exception,Exception是throwable的子类,是所有异常的基类。与此同时,throwable还有另一个子类,也就是Error。这里会把Exception这个引用抛到外部环境中去处理。

    throw跟try...catch...finally的对比:

     try catch是直接处理,处理完成之后程序继续往下执行,throw则是将异常抛给它的上一级处理,程序便不往下执行了。

    public class ZeroTest {
        public static void main(String[] args) {
         try{
           int i = 100/ 0;
           System.out.print(i);
      }catch(Exception e){
           System.out.print(1);
           throw new RuntimeException();
      }finally{
           System.out.print(2);
      }
          System.out.print(3);
      }
    }


    上述代码中的catch语句块里面,打印完1之后,又抛出了一个RuntimeException,程序并没有处理它,而是直接抛出,
    因此执行完finally语句块之后,程序终止了。
    首先执行try,遇到算术异常,抛出,执行catch,打印1,然后抛出RuntimeException,缓存异常,执行finally,打印2,然后抛出RuntimeException。
    如果catch中没有抛出RuntimeException,则执行结果为123。

    三、throws

    throws并不是抛出一个实际的Exception而是一个异常声明,它声明这个方法可能会抛出一个异常,注意是可能,所以在没有异常的情况下也是可以用throws的,而throws本身的作用也是用来提高程序的健壮性,反过来,如果这个方法的的确有一个异常,那么编译器会强制让加上throws异常声明。

    通常throws是写在参数列表的后面,表明这个方法有可能会抛出一个异常。

    class A{
       
        public void g() throws Exception{
            
        }
    }

    四、try-catch、throw、throws之间的区别与联系

    区别一:

    throw 是语句抛出一个异常;throws 是方法抛出一个异常;

    throw语法:throw <异常对象>

    throws语法:[<修饰符>]<返回值类型><方法名>([<参数列表>])[throws<异常类>]

    在方法声明中,添加throws子句表示该方法将抛出异常。如果一个方法会有异常,但你并不想处理这个异常,就在方法名后面用throws,这样这个异常就会抛出,谁调用了这个方法谁就要处理这个异常,或者继续抛出。其中:异常类可以声明多个,并用逗号分割。

    区别二:

    throw可以与try-catch-finally语句块一起使用,也可以与throws一起使用。

    throws一般单独使用,然后再由处理异常的方法捕获。

    联系一:

    try .... catch 就是用catch 捕获 try 中某一个操作可能会出现的异常并处理。

    throw 不处理异常,而直接抛出异常。throw new Exception()是抛出一个Exception,由其他的method来处理这个Exception。

    所以:try....catch是为捕获Exception用的,而throw是抛出Exception让别人去捕获。

    如果一个方法中用了throws,那么这个方法会向上抛出一个异常,那么在调用这个方法的时候必须把这个调用放在try...catch块里处理这个异常。

    异常的处理方法有两种:

    1、声明异常,即在方法名后面加上throws ExceptionName,..., 方法本身只是抛出异常,由函数调用者来捕获异常。若产生异常,异常会顺着调用栈一直找到与之匹配的处理方法,若到达调用栈底仍未找到,就输出异常并终止程序。

    2、捕获异常。通过try catch方法,catch子句中放置处理异常的语句。

    联系二:

    对于可能有异常抛出的程序块,用try{}包住,然后用catch来抓住这个异常,在catch中对异常做处理, 在try中如果有异常的话,程序会转到catch而不会中断。

    try和catch只能获取程序运行时引发的异常,而throw语句可以引发明确的异常,程序到了throw语句这后就立即停止,不会执行后面的程序。

     

    本文部分段落摘自以下文章:

     https://blog.csdn.net/qq_30715329/article/details/85463461

    https://blog.csdn.net/abc19900828/article/details/7889879

    https://blog.csdn.net/ztx114/article/details/78251126

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

    千次阅读 2016-12-12 12:01:15
    在Java的trycatch、finally中,try是必须的,catch和finally都不是必须的。 因为捕获异常是必须要有的,而捕获到异常之后,如果不做处理,那就不用写catch,如果需要对捕获到异常之后做处理才需要catch,finally也...
    在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,即只有try和finally没有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;
    

     

    展开全文
  • 记得园子里有位网友使用StopWatch分析过Try-Catch在不同情况下,与无Try-Catch的代码相比,代码运行的时间指标,结果并没有很大差异。 下面我来结合IL分析一下Try-Catch吧。 ● 机制分析  .Net 中基本的异常捕获与...
  • Try catch如何使用

    千次阅读 2019-05-16 18:43:36
    try catch适用场合: 一、兼容性 浏览器的兼容性是程序员很头痛的事儿,往往一些出错会让我们查找许久,在使用try catch能更好的解决兼容性出错的问题:由于不同浏览器报错提示也不尽相同,通过使用try catch捕获的...
  • try catch的作用

    千次阅读 多人点赞 2018-03-29 11:25:16
    try catch的作用:当程序发生错误时,能够保证程序继续执行下去。用一个简单例子说明:1:无try catchpublic static void main(String[] args) { int i; i = 2/0; System.out.println(i); System.out.println...
  • C++ ,VS2010平台编辑,下载后可以直接使用,异常处理(try_catch
  • C++ try……catch catch(CException *e) 打印异常信息 不经意间的内存泄露:try-catch(CException *e) [异常对象需要手动释放] C++ try catch 捕获空指针异常,数组越界异常 C++ try catch 异常类 异常类大全 C...
  • 编译错误:Try没有catch或者Finally

    千次阅读 2008-10-09 20:26:00
    Syntax error, insert "Finally" to complete BlockStatements try without catch or finally错误样例:class T { void test(){ try{ } }}
  • java 异常 try catch throw

    2017-12-02 15:31:38
    java 中 try {throw1...}catch {throw2...}finally{throw3...}, 请帮忙解释一下上述简易代码如何执行
  • try-catch语句

    万次阅读 2019-08-17 01:15:40
    try-catch 语句,作为 JavaScript 中处理异常的一种标准方式。基本的语法如下所示: try{ // 可能会导致错误的代码 } catch(error){ // 在错误发生时怎么处理 } 如果 try 块中的任何代码发生了错误,就会立即...
  • IDEAl中try-catch的快捷键

    千次阅读 热门讨论 2020-10-19 20:41:52
    try-catch的快捷键是Ctrl+Alt+T 我想要将下图中代码用try-catch包裹 下面是详细步骤: 第一步:选中你想要进行try-catch的代码 第二步使用快捷键Ctrl+Alt+T 选择try-catch选项 选择之后,目标段就被try-catch包裹...
  • trycatch的用法

    千次阅读 多人点赞 2020-04-30 16:12:45
    执行规则:首先执行try中的代码 如果抛出异常会由catch去捕获并执行 如果没有发生异常 catch去捕获会被忽略掉 但是不管有没有异常最后都会执行。 try 语句使你能够测试代码块中的错误。 catch 语句允许你处理错误。 ...
  • try-catch-finally 中哪个部分可以省略? catch 和 finally 语句块可以省略其中一个。 package constxiong.interview; public class TestOmitTryCatchFinally { public static void main(String[] args) { ...
  • try -catch-catch异常的执行顺序

    千次阅读 2018-10-11 23:13:18
    大家都知道try-catch是捕获异常的,我自己也是这么明白,却不知道多个catch是怎么操作。 就决定自己试验一下 public class Try { public static void main(String[] args) { int[] arr = new int[5]; ...
  • try catch 语句

    千次阅读 2019-05-22 15:25:00
    try代码块抛出错误(上例用的是throw语句),JavaScript 引擎就立即把代码的执行,转到catch代码块,或者说错误被catch代码块捕获了。catch接受一个参数,表示try代码块抛出的值。 如果你不确定某些代码是否会报错,...
  • try catch里面try catch嵌套

    万次阅读 2018-05-18 13:26:54
    try catch里面try catch嵌套
  • C++中try/catch/throw的使用

    万次阅读 多人点赞 2017-03-25 19:12:46
    C++异常处理涉及到三个关键字:trycatch、throw。 在C++语言中,异常处理包括: (1)、throw表达式:异常检测部分使用throw表达式来表示它遇到了无法处理的问题,throw引发了异常。throw表达...
  • try/catch 的解释与用法

    万次阅读 多人点赞 2018-08-03 19:45:20
    目录 目录 定义 语法 注意: 多重捕获块 举例 1. NullPointerException 空指针异常 2. ArrayIndexOutOfBoundsException 数组下标越界异常 3. ArithmeticException ...5. IllegalAccessException 没有访问权限...
  • async和await异步捕获机制try/catch

    千次阅读 2020-05-09 09:01:24
    但是其中对于错误的处理一不小心就会忽略掉,特别是目前公司使用的weex作为开发框架,本身的debug的处理极其有限并且不便,当在项目中使用了大量的await / async语句并且没有捕获机制的话,代码很容易就产生错误并且...
  • PHP中trycatch、finally的执行顺序

    千次阅读 2020-06-02 17:09:18
    目录一、图片二、异常处理try-catch-finally1、地址2、解释三、PHP中trycatch、finally的执行顺序1、地址2、打比方3、解释四、php 关于try catch finally的执行顺序解释1、地址2、解释 一、图片 二、异常处理try-...
  • Java:简述try-catch-finally异常捕获

    千次阅读 多人点赞 2019-02-14 17:02:58
    Java:简述try-catch-finally异常捕获 在Java中,异常通过try-catch语句捕获。其一般语法形式为: try { // 可能会发生异常的程序代码 } catch (Type1 id1){ // 捕获并处置try抛出的异常类型Type1 } catch ...
  • 事务 与 try/catch的关系

    千次阅读 2019-05-09 20:10:36
    在我们使用@Transactional事务的注解的时候,如果用到try/catch,不可避免的会出现下面的这两种情况: try{ gameMapper.insertGame(game); int a = 6/0; gameMapper.findGameById(gameId); }catch(Excetion e){...
  • 前端老司机 try-catch 的使用

    千次阅读 2019-05-28 15:21:38
    try catch 的用途 在程序逻辑中,需要在易出现问题的逻辑代码片段上,加持try-catch方法。 这样做可以抛出错误,但是不会影响整个程序运转。 try { // 你的逻辑代码片段 } catch (e) { // 错误处理代码片段 } .....
  • try catch finally 用法

    千次阅读 多人点赞 2018-10-13 19:34:59
     正常情况下,先执行try里面的代码,捕获到异常后执行catch中的代码,最后执行finally中代码,但当在try catch中执行到return时,要判断finally中的代码是否执行,如果没有,应先执行finally中代码再返回。...
  • IntelliJ IDEA - try / catch / finally 快捷键

    千次阅读 2019-10-09 23:51:11
    选中想被 try / catch / finally 包围的语句,同时按下 Ctrl +Alt + T,如图
  • idea中try/catch的快捷键

    万次阅读 多人点赞 2019-05-14 23:00:35
    在代码中我们经常需要捕获异常,这时候快捷键的时候就可以事半功倍 ctrl + alt + t

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,469,846
精华内容 987,938
关键字:

try没有catch