try 订阅
TRY为青春女子三人组合。第一代成员:贡维特 Tenny、王蕊Readis、陶钰玉 Youty。第二代成员:林可昕Treecy、王奕心Readis、沈丹丹 Erica。 展开全文
TRY为青春女子三人组合。第一代成员:贡维特 Tenny、王蕊Readis、陶钰玉 Youty。第二代成员:林可昕Treecy、王奕心Readis、沈丹丹 Erica。
信息
职    业
歌手
国    籍
中华人民共和国
代表作品
frosty the snowman 等
经纪公司
孔雀唱片
中文名
青春女子三人组合
原成员
贡维特、王 蕊、陶钰玉
现成员
林可昕、王奕心、沈丹丹
外文名
T.R.Y
扫描隧道显微镜简介
收起全文
精华内容
下载资源
问答
  • python笔记——try except方法

    万次阅读 多人点赞 2019-06-02 20:49:53
    2、try except方法 一、常见错误总结 AttributeError 试图访问一个对象没有的树形,比如foo.x,但是foo没有属性x IOError 输入/输出异常;基本上是无法打开文件 ImportError 无法引入模块或包;基本上是路径问题或...

    本文结构:
    1、常见错误总结
    2、try except方法

    一、常见错误总结


    • AttributeError 试图访问一个对象没有的树形,比如foo.x,但是foo没有属性x
    • IOError 输入/输出异常;基本上是无法打开文件
    • ImportError 无法引入模块或包;基本上是路径问题或名称错误
    • IndentationError 语法错误(的子类) ;代码没有正确对齐
    • IndexError 下标索引超出序列边界,比如当x只有三个元素,却试图访问x[5]
    • KeyError 试图访问字典里不存在的键
    • KeyboardInterrupt Ctrl+C被按下
    • NameError 使用一个还未被赋予对象的变量
    • SyntaxError Python代码非法,代码不能编译(个人认为这是语法错误,写错了)
    • TypeError 传入对象类型与要求的不符合
    • UnboundLocalError 试图访问一个还未被设置的局部变量,基本上是由于另有一个同名的全局变量,
      导致你以为正在访问它
    • ValueError 传入一个调用者不期望的值,即使值的类型是正确的

    二、try except方法


    有时候我们写程序的时候,会出现一些错误或异常,导致程序终止,这个时候我们需要捕获错误的类型,让代码更灵活,下面介绍下常用的try except来进行捕获异常的方法。

    1. 处理单个异常:

    • 语法:
    >>> try:
    >>>     code
    >>> except Error1 as e:  #处理Error1异常
    >>>     print(e)
    
    • demo
    >>> try>>>     print(5/0)           #该行为测试的语句
    >>> except  ZeroDivisionError as e:              ## 如果测试的语句出现except后的异常(例中的ZeroDivisionError),则执行下一行代码,否则跳过此模块
    >>>     print(e)               ## 打印错误名称
    division by zero        ##执行结果
    
    1. 分开处理多个异常:

    • 语法
    >>> try:
    >>>     code
    >>> except Error1 as e:  #处理Error1异常
    >>>     print(e)
    >>> except Error2 as e:   #处理Error2异常    
    >>>     print(e)
    
    • demo
    >>> a = [0,1]
    >>> try:
    >>>     print(a[3])  
    >>>     print(5/0)   ##语句在上一行就遇到错误传到except里面去了,未检测到此语句 
    >>> except ZeroDivisionError as e:  #处理Error1异常
    >>>     print(e)
    >>> except IndexError as e:   #处理Error2异常    
    >>>     print(e)
    list index out of range
    
    1. 统一处理多个异常:

    • 语法
    >>> try:
    >>>     code
    >>> except (Error1,Error) :    ###无论遇到什么异常,都只会执行下一行要打印的一种东西
    >>>     print(e)
    
    1. 没有异常,则走else部分的逻辑代码

    • 语法:
    >>> try:
    >>>     code
    >>> except (Error1,Error2,...) as e:
    >>>     print(e)
    >>> else:
    >>>     print("没有错误,执行")
    
    • demo
    >>>  try>>>     print(5/1)           
    >>> except  ZeroDivisionError as e:             
    >>>     print(e)              
    >>> else:
    >>>     print("没有错误")
    没有错误
    
    1. 不管有没有错误,都会执行finnally中的代码
      例如在对文件进行操作时候,如果文件读写过程中出现错误,无法关闭,可以将f.close()放在finally中,这样无论是否有错误,文件都会关闭

    >>> try:
    >>>     code
    >>> except (Error1,Error2,...) as e:
    >>>     print(e)
    >>> else:
    >>>     print("没有错误,执行")
    >>> finnally:
    >>>     print("不管有没有错,都执行finnally")
    
    展开全文
  • Python Try Catch异常教程

    千次阅读 2020-10-10 10:55:48
    LEARN MORE Linux "Command Not Found" Error And Solution 了解更多Linux“找不到命令”错误和解决方案 使用try和Except捕获异常(Catch An Exception with Try and Except) Now we want to prevent this type of...

    As a developer, we have a lot of thoughts about the applications and features. Implementing them a tedious task. During the implementation, we can make mistakes. Those mistakes can be related to applications logic or technical. These errors will cause problems while the application is running. We call this type of problem as exceptions. We can not prevent all exceptions but we can create some mechanisms to handle these situations. In this tutorial, we will look at how to handle these exceptions.

    作为开发人员,我们对应用程序和功能有很多想法。 实施它们是一项繁琐的任务。 在实施过程中,我们可能会犯错误。 这些错误可能与应用程序逻辑或技术有关。 这些错误将在应用程序运行时引起问题。 我们称这类问题为例外。 我们无法防止所有异常,但可以创建一些机制来处理这些情况。 在本教程中,我们将研究如何处理这些异常。

    什么是例外 (What is An Exception)

    Some of us may be familiar with exceptions but there may be others who do not have any idea about exceptions. Exceptions are unexpected error situations where applications generally stop working. Sometimes it will not stop working but will not work properly either.

    我们中的有些人可能对异常很熟悉,但有些人可能对异常一无所知。 异常是应用程序通常停止运行的意外错误情况。 有时它不会停止工作,但也不能正常工作。

    Here is an example of how an exception occurs. Our applications get input from the user and multiple given numbers. But there will be an exception if the user inputs string. The filename is myapp.py .

    这是一个异常发生情况的示例。 我们的应用程序从用户和多个给定的数字中获取输入。 但是,如果用户输入字符串,则会出现异常。 文件名是myapp.py

    #!/usr/bin/python3 
     
    num1 = input ("Enter number") 
     
    print(num1*num1)

    When we call our application like below by providing a character like othera then a number we will get an exception.

    当我们调用的应用程序像下面通过提供像其他字符a接着一个号码,我们会得到一个异常。

    $ python3 myapp.py
    What is An Exception
    What is An Exception
    什么是例外

    We also get the exception type. Python provides a different type of exceptions for different situations. In this code the exception type is TypeError .

    我们还获得了异常类型。 Python针对不同情况提供了不同类型的异常。 在此代码中,异常类型为TypeError

    异常类型 (Exception Types)

    As there are a lot of different libraries and function there is a different type of exceptions. Here some of the most popular of them.

    由于存在许多不同的库和函数,因此存在不同类型的异常。 在这里,其中一些最受欢迎。

    • Exception is the generic and base class for all exceptions.

      Exception是所有异常的通用和基类。

    • StopIteration exception raised when the next() method of an iterator does not point to any object.

      当迭代器的next()方法未指向任何对象时,引发StopIteration异常。

    • SystemExit exception raised by the sys.exit() function.

      sys.exit()函数引发的SystemExit异常。

    • StandardError is a base class and exception for all built-in exceptions except StopIteration and SystemExit.

      StandardError是除StopIteration和SystemExit之外的所有内置异常的基类和异常。

    • ArithmeticError is a base class for all error that occurs during mathematical and arithmetic calculations and operators.

      ArithmeticError是所有在数学和算术计算以及运算符期间发生的错误的基类。

    • OverFlowError exception raised when calculation exceeds the maximum limit for given numerical type.

      当计算超出给定数值类型的最大限制时引发OverFlowError异常。

    • ZeroDivisionError exception raised when a division or modulo by zero takes place for numerical operations.

      在对数字运算进行除数或以零为模时引发ZeroDivisionError异常。

    • AssertionError raised in case of failure of the assert Python programming language statement.

      在断言Python编程语言语句失败的情况下引发AssertionError

    • AttributeError exception raised in case of failure of attribute reference or assignment.

      在属性引用或分配失败的情况下引发AttributeError异常。

    • EOFError exception raised when there is no input or the end of a file is reached.

      没有输入或到达文件末尾时EOFError异常。

    • ImportError exception raised when an import Python programming language statement fails.

      导入Python编程语言语句失败时引发ImportError异常。

    • KeyboardInterrupt exception raised when the user interrupts the execution of the application with Linux kill command or pressing CTRL+C keyboard shortcut.

      当用户使用Linux kill命令或按CTRL + C键盘快捷键中断应用程序的执行时,将引发KeyboardInterrupt异常。

    • LookupError exception raised for all lookup errors.

      针对所有查找错误引发LookupError异常。

    • IndexError exception raised when an index is not found in the array, list in a sequence.

      当在数组中找不到索引时,引发序列错误IndexError异常。

    • KeyError exception raised when the specified key is not found in the dictionary.

      在字典中找不到指定的键时引发KeyError异常。

    • NameError exception raised when an identifier is not found in the local or global namespace.

      在本地或全局名称空间中找不到标识符时引发NameError异常。

    • UnboundLocalError exception raised when trying to access a local variable in a function, method, module but no value has been assigned to it.

      尝试访问函数,方法,模块中的局部变量但未分配任何值时引发了UnboundLocalError异常。

    • EnvironmentError is based class for all exceptions that occur outside of the Python Environment.

      EnvironmentError是Python环境外部发生的所有异常的基类。

    • IOError exception raised when an input/output operations fail, such as writing a file failed or a file can not be opened.

      当输入/输出操作失败(例如,写入文件失败或无法打开文件)时, IOError异常。

    • SyntaxError exception raised when there is an error related to the Python Syntax.

      与Python语法相关的错误时引发SyntaxError异常。

    • IndentationError exception raised when indentation is not specified and used properly to catch code block.

      未指定缩进并正确用于捕获代码块时引发IndentationError异常。

    • SystemError exception raised when the Python interpreter finds and, internal problem.

      当Python解释器发现and内部问题时,引发SystemError异常。

    • TypeError exception raised when an operation, function, method is attempted to get, set different type of variable or data type.

      尝试获取操作,函数,方法,设置不同类型的变量或数据类型时TypeError异常。

    • ValueError exception raised when built-in function fora data type has the valid type of arguments, but the arguments have invalid values.

      当数据类型的内置函数具有有效类型的参数,但参数具有无效值时,引发ValueError异常。

    • RuntimeError exception raised when the raised exception or error does not suit any specific category.

      当引发的异常或错误不适合任何特定类别时,引发RuntimeError异常。

    • NotImplementedError exception raised when an abstract method that is not implemented tried to be used.

      尝试使用未实现的抽象方法时引发NotImplementedError异常。

    LEARN MORE  Linux "Command Not Found" Error And Solution
    了解更多Linux“找不到命令”错误和解决方案

    使用try和Except捕获异常(Catch An Exception with Try and Except)

    Now we want to prevent this type of bugs and exceptions programmatically. Python provides a mechanismtry which is used to detect exceptions in the given block of the code. We will put the potential error block into liketry below. Here we guess that lineprint(num1-num1) can raise an exception.

    现在,我们要以编程方式防止此类错误和异常。 Python提供了一种机制try ,用于检测给定代码块中的异常。 我们将潜在的错误块放入下面的try中。 在这里,我们猜测行print(num1-num1)会引发异常。

    #!/usr/bin/python3 
     
    num1 = input ("Enter number") 
     
    try: 
       print(num1*num1) 
     
    except: 
       print("An error occured") 
        
     
    print("Operation completed")

    When we run by providing a character like ita will not raise an exception. It simply skips to the codeexcept block which will run if an exception is raised. Then the application will flow in a normal situation.

    当我们通过提供个性像它运行a不会引发异常。 它只是跳到exceptexcept的代码,如果引发异常,该块将运行。 然后,应用程序将在正常情况下运行。

    Handle An Exception with Try and Except
    Handle An Exception with Try and Except
    使用try和Except处理异常

    捕获特定异常(Catching Specific Exceptions)

    In the previous example, we have fired a single type of exception with the codeexcept block. But we can catch a specific type of exception and ignoring others. As we remember from the first example we get the exceptionTypeError. If we only need to catch an exceptionTypeError and ignore others we will specify toTypeError the likeexcept below.

    在前面的示例中,我们使用代码except块触发了一种异常类型。 但是我们可以捕获特定类型的异常并忽略其他异常。 我们记得在第一个示例中,我们得到了TypeError 。 如果我们只需要捕获TypeError并忽略其他异常,我们将为TypeError指定以下内容, except下面的内容。

    #!/usr/bin/python3 
     
    num1 = input ("Enter number") 
     
    try: 
       print(num1*num1) 
     
    except TypeError: 
       print("An TypeError occurred") 
     
     
    print("Operation completed")
    Catching Specific Exceptions
    Catching Specific Exceptions
    捕获特定异常

    否则,如果未引发异常(Else If No Exception Raised)

    We generally expect to raise some exception while running critical code. But in some cases, there will be no error or exception. We can define some code to execute if there is no error and exception to the else keyword. We will put the code we want to run if there is no error or exception inside else keyword block. In this example, we will print the screen “There is no exception” if there is no error or exception.

    我们通常希望在运行关键代码时引发一些异常。 但是在某些情况下,不会有错误或异常。 如果else关键字没有错误和异常,我们可以定义一些要执行的代码。 如果else关键字块中没有错误或异常,我们将放置我们要运行的代码。 在此示例中,如果没有错误或异常,我们将打印“无异常”屏幕。

    #!/usr/bin/python3 
    
    num1 = input ("Enter number") 
    
    try:   print(num1*num1) 
    
    except TypeError:   
       print("An TypeError occurred") 
    
    else: 
       print("There is no exception")
    
    print("Operation completed")

    捕获多个类型异常 (Catch Multiple Type Exceptions)

    We may need to catch multiple exceptions in a single except code block. We will provide the exception types in brackets by separating them with command (TypeA , TypeB , TypeC , ...)

    我们可能需要赶在一个多例外except代码块。 我们将在括号中提供例外类型,方法是使用命令将它们分开(TypeA , TypeB , TypeC , ...)

    In this example we will catch both TypeError and ZeroDivisionError .

    在此示例中,我们将捕获TypeErrorZeroDivisionError

    #!/usr/bin/python3 
     
    num1 = input ("Enter number") 
     
    try: 
       print(num1*num1) 
     
    except (TypeError,ZeroDivisionError): 
       print("An TypeError occured") 
     
     
    print("Operation completed")

    最终后在异常后运行代码 (Run Code After Exception with Finally)

    While checking exceptions in try code block we may need to execute some come whatever happens even try code block works or except code block works. We will use finally code block to complete the try-except blocks. After the try-except blocks finally, the code block will be run. This is generally used to release resources like file, database connection, or revert operations used in try code block.

    在检查try代码块中的异常时,我们可能需要执行一些意外的事情,即使try代码块工作或除代码块工作之外。 我们将使用finally代码块完成try-except块。 最后,在try-except块之后,将运行代码块。 通常用于释放资源,如文件,数据库连接或try代码块中使用的还原操作。

    LEARN MORE  Apache Log Files
    了解更多Apache日志文件

    In this example, we will close file-handle in the finally code block whether previous code blocks work or raise an exception.

    在此示例中,我们将关闭finally代码块中的文件句柄,而不管先前的代码块是否起作用或引发异常。

    #!/usr/bin/python3 
     
    try: 
       f = open("personels.txt") 
       f.read() 
     
    finally: 
       f.close()

    引发异常 (Raise Exception)

    Up to now, we have handled self-raised exceptions. We can also raise an exception manually without waiting for a user to input any change. We will use keywordraise in order to raise an exception manually. In this example, we will raise typeZerrorDivisionError exception.

    到目前为止,我们已经处理了自举异常。 我们还可以手动引发异常,而无需等待用户输入任何更改。 我们将使用关键字raise以手动引发异常。 在此示例中,我们将引发ZerrorDivisionError类型的异常。

    #!/usr/bin/python3 
     
    try: 
       print("0/0") 
       raise ZeroDivisionError 
     
    except (ZeroDivisionError): 
       print("An ZeroDivisionError occurred") 
     
     
    print("Operation completed")
    Raise Exception
    Raise Exception
    引发异常

    用户定义的异常(User-Defined Exceptions)

    While programming enterprise applications and libraries we will need to create our exception type library too. We may need to provide operational exceptions like invalid move operations for files. We can define our own user-defined exceptions by using classRuntimeError like below. We will put the following code into CorpExceptions.py

    在对企业应用程序和库进行编程时,我们也需要创建异常类型库。 我们可能需要提供操作异常,例如文件的无效移动操作。 我们可以使用如下所示的类RuntimeError来定义自己的用户定义的异常。 我们将以下代码放入CorpExceptions.py

    #!/usr/bin/python3 
     
    class InvalidMove(RuntimeError): 
       def __init__(self, arg): 
          self.args = arg

    and we can raise as we did before after importing CorpExceptions.py

    在导入CorpExceptions.py之后,我们可以像以前一样提高

    raise InvalidMode

    翻译自: https://www.poftut.com/python-try-catch-exceptions-tutorial/

    展开全文
  • Scala 优雅的异常处理之 tryTry

    千次阅读 2020-07-29 11:35:23
    Scala 异常处理之 tryTry java将所有的错误封装为一个对象,父类为Throwable, Throwable下有两个子类:Error和Exception。scala本质上和java一样,都是运行在jvm上,同理scala也有和java类似的try catch异常...

    Scala 优雅的异常处理之 try 与 Try

    java将所有的错误封装为Throwable,Throwable下有两个子类:Error和Exception。scala本质上和java一样,都是运行在jvm上,同理scala也有和java类似的try catch异常处理机制,好处是scala有很多语法糖,在异常处理过程中可以节省开发者很大精力,下面看一下scala异常处理try与Try的使用:

     

    try

    基本写法

    try是scala内用作异常处理的写法,最常用的写法就是 try catch finally

      def tryDemo(): Unit = {
        // try
        val label = try {
          val value = redis.get("key")
          if (noRes.contains(value)) {
            "-1"
          } else {
            "1"
          }
        } catch {
          case e: Exception => {
            e.printStackTrace()
            "-1"
          }
        } finally {
          println("label处理完毕")
        }
        println(label)
      }

    Exception

    这里catch到exception会进行异常处理,并返回默认值-1,Exception是java.lang.Exception,catch Exception会捕捉到如下Exception异常,但是捕捉不到error的情况:

    java.lang.RuntimeException系统异常
    java.lang.NullPointerException空指针异常
    java.lang.ClassCastException类型转换异常
    java.lang.IndexOutOfBoundsException下标越界
    java.lang.ArrayIndexOutOfBoundsException数组下标越界
    java.lang.StringIndexOutOfBoundsException字符串下标越界
    java.lang.UnsupportedOperationException不支持的操作异常
    java.lang.IllegalArgumentException非法参数异常
    java.lang.NoSuchElementException方位未找到异常
    java.lang.NumberFormatException数字格式异常
    java.lang.AbstractMethodError抽象方法错误
    java.lang.InterruptedException中断异常

    Error

    error是java.lang.Error,如果需要捕捉非Exception类异常,则只需修改成如下写法:

          case e: Error => {
            xxx
          }

    一般在连接网络,初始化服务器失败时,会出现error的情况,一般情况下写bug的时候多为Exception

    Scala语法糖

    scala支持 _ 代表一切,常见的map(_.toString),foreach(println(_))等等,这里try catch支持这样的写法:

          case _ => {
            xxx
          }

    catch后加这个可以视为捕捉一切异常,error,exception都包括,偷懒情况下或者对异常情况不清楚可以这么写,不过代码可读性差,而且maven打包时会提醒打包的warning。

     

    Try

    Try的机制有点类似option和Future,如果需要最终获取其中的值,需要通过.get获取,因为他们的执行都是不确定性的。

    基本写法

        val numStr = "0"
        val num = Try(numStr.toInt).get
        println(num,num.getClass)
    (0,int)

    源码

    object Try {
      /** Constructs a `Try` using the by-name parameter.  This
       * method will ensure any non-fatal exception is caught and a
       * `Failure` object is returned.
       */
      def apply[T](r: => T): Try[T] =
        try Success(r) catch {
          case NonFatal(e) => Failure(e)
        }
    
    }

    就是我们执行的操作,是执行后返回的结果,针对上面的例子,toIntInt,这里可以看到Try底层其实也是在使用try,Success是Try内的case class,也是Try的子类,类内提供了isSuccess,isFailure等方法,其返回值也是Try[T],e 是执行try时抛出的异常,从下面源码看到就是Throwable,包含了Error和Exception,当捕捉到异常时返回Failure,Failure和Success一样,也是Try的子类。

    object NonFatal {
       /**
        * Returns true if the provided `Throwable` is to be considered non-fatal, or false if it is to be considered fatal
        */
       def apply(t: Throwable): Boolean = t match {
         // VirtualMachineError includes OutOfMemoryError and other fatal errors
         case _: VirtualMachineError | _: ThreadDeath | _: InterruptedException | _: LinkageError | _: ControlThrowable => false
         case _ => true
       }
      /**
       * Returns Some(t) if NonFatal(t) == true, otherwise None
       */
      def unapply(t: Throwable): Option[Throwable] = if (apply(t)) Some(t) else None
    }

    模式匹配判断Try内是否成功执行 match

          import scala.util.{Failure, Success, Try}      
          Try(num.toInt) match {
            case Success(value) => println("Success")
            case Failure(exception) => println("False")
            case _ => println("unKnown")
          }

    通过match case模式匹配以及scala自带的Success类和Failure类,可以判断Try内逻辑是否执行正常,执行正常返回Success,执行错误返回Failure,这里.toInt是最常用的写法,里面也可以写复杂的逻辑,例如需要一些网络请求的任务,或者文件IO等等

    恢复模式匹配并做异常处理 recover

        Try(num.toInt) recover {
          case e: Exception => 0
          case e: Error => 1
          case _ => 2
        }

    这里和try catch flinaly其实两种写法都可以达成上述效果,即异常捕捉与修复,当Try内抛出异常时,根据异常处理判断出现异常后的处理动作,如果执行结果状态为Success,则不会触发后续的recover。

    简洁写法

    针对上述case match和recover,Try也提供了更简便的写法供开发者使用,即getOrElse,如果Try内成功,返回T,否则返回默认值,类似map和jsonObject的getOrElse。

    A.try catch

        try {
          num.toInt
        } catch {
          case e: Exception => 0
        } 

    B.if else

          if (num != null && num != "") {
            num.toInt
          } else {
            0
          }

    C.Try

    Try(num.toInt).getOrElse(0)

     

    展开全文
  • 技术大佬:我去,你竟然还在用 try–catch-finally

    万次阅读 多人点赞 2020-04-04 07:40:38
    网上看到一幅 Python 程序员调侃 Java 程序员的神图,直接 copy 过来(侵删),逗你一乐: 况且,try–catch-finally 至始至终存在一个严重的隐患:try 中的 br.readLine() 有可能会抛出 IOException,finally 中的...

    二哥,你之前那篇 我去 switch 的文章也特么太有趣了,读完后意犹未尽啊,要不要再写一篇啊?虽然用的是 Java 13 的语法,对旧版本不太友好。但谁能保证 Java 不会再来一次重大更新呢,就像 Java 8 那样,活生生地把 Java 6 拍死在了沙滩上。Java 8 是香,但早晚要升级,我挺你,二哥,别在乎那些反对的声音。

    这是读者 Alice 上周特意给我发来的信息,真令我动容。的确,上次的“我去”阅读量杠杠的,几个大号都转载了,包括 CSDN,次条当天都 1.5 万阅读。但比如“还以为你有什么新特技,没想到用的是 Java 13”这类批评的声音也不在少数。

    不过我的心一直很大。从我写第一篇文章至今,被喷的次数就好像头顶上茂密的发量一样,数也数不清。所以我决定再接再厉,带来新的一篇“我去”。

    这次不用远程 review 了,因为我们公司也复工了。这次 review 的代码仍然是小王的,他编写的大部分代码都很漂亮,严谨的同时注释也很到位,这令我非常满意。但当我看到他没用 try-with-resources 时,还是忍不住破口大骂:“我擦,小王,你丫的竟然还在用 try–catch-finally!”

    来看看小王写的代码吧。

    public class Trycatchfinally {
        public static void main(String[] args) {
            BufferedReader br = null;
            try {
                br = new BufferedReader(new FileReader("/牛逼.txt"));
                String str = null;
                while ((str =br.readLine()) != null) {
                    System.out.println(str);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (br != null) {
                    try {
                        br.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    

    咦,感觉这段代码很完美无缺啊,try–catch-finally 用得中规中矩,尤其是文件名 牛逼.txt 很亮。不用写注释都能明白这段代码是干嘛的:在 try 块中读取文件中的内容,并一行一行地打印到控制台。如果文件找不到或者出现 IO 读写错误,就在 catch 中捕获并打印错误的堆栈信息。最后,在 finally 中关闭缓冲字符读取器对象 BufferedReader,有效杜绝了资源未被关闭的情况下造成的严重性能后果。

    在 Java 7 之前,try–catch-finally 的确是确保资源会被及时关闭的最佳方法,无论程序是否会抛出异常。

    但是呢,有经验的读者会从上面这段代码中发现 2 个严重的问题:

    1)文件名“牛逼.txt”包含了中文,需要通过 java.net.URLDecoder 类的 decode() 方法对其转义,否则这段代码在运行时铁定要抛出文件找不到的异常。

    2)如果直接通过 new FileReader("牛逼.txt") 创建 FileReader 对象,“牛逼.txt”需要和项目的 src 在同一级目录下,否则同样会抛出文件找不到的异常。但大多数情况下,(配置)文件会放在 resources 目录下,便于编译后文件出现在 classes 目录下,见下图。

    为了解决以上 2 个问题,我们需要对代码进行优化:

    public class TrycatchfinallyDecoder {
        public static void main(String[] args) {
            BufferedReader br = null;
            try {
                String path = TrycatchfinallyDecoder.class.getResource("/牛逼.txt").getFile();
                String decodePath = URLDecoder.decode(path,"utf-8");
                br = new BufferedReader(new FileReader(decodePath));
    
                String str = null;
                while ((str =br.readLine()) != null) {
                    System.out.println(str);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (br != null) {
                    try {
                        br.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    

    运行这段代码,程序就可以将文件中的内容正确输出到控制台。但如果你对“整洁”这个词心生向往的话,会感觉这段代码非常臃肿,尤其是 finally 中的代码,就好像一个灌了 12 瓶雪花啤酒的大肚腩。

    网上看到一幅 Python 程序员调侃 Java 程序员的神图,直接 copy 过来(侵删),逗你一乐:

    况且,try–catch-finally 至始至终存在一个严重的隐患:try 中的 br.readLine() 有可能会抛出 IOException,finally 中的 br.close() 也有可能会抛出 IOException。假如两处都不幸地抛出了 IOException,那程序的调试任务就变得复杂了起来,到底是哪一处出了错误,就需要花一番功夫,这是我们不愿意看到的结果。

    为了模拟上述情况,我们来自定义一个类 MyfinallyReadLineThrow,它有两个方法,分别是 readLine()close(),方法体都是主动抛出异常。

    class MyfinallyReadLineThrow {
        public void close() throws Exception {
            throw new Exception("close");
        }
    
        public void readLine() throws Exception {
            throw new Exception("readLine");
        }
    }
    

    然后我们在 main() 方法中使用 try-finally 的方式调用 MyfinallyReadLineThrow 的 readLine()close() 方法:

    public class TryfinallyCustomReadLineThrow {
        public static void main(String[] args) throws Exception {
            MyfinallyReadLineThrow myThrow = null;
            try {
                myThrow = new MyfinallyReadLineThrow();
                myThrow.readLine();
            } finally {
                myThrow.close();
            }
        }
    }
    

    运行上述代码后,错误堆栈如下所示:

    Exception in thread "main" java.lang.Exception: close
    	at com.cmower.dzone.trycatchfinally.MyfinallyOutThrow.close(TryfinallyCustomOutThrow.java:17)
    	at com.cmower.dzone.trycatchfinally.TryfinallyCustomOutThrow.main(TryfinallyCustomOutThrow.java:10)
    

    readLine() 方法的异常信息竟然被 close() 方法的堆栈信息吃了,这必然会让我们误以为要调查的目标是 close() 方法而不是 readLine()——尽管它也是应该怀疑的对象。

    但自从有了 try-with-resources,这些问题就迎刃而解了,只要需要释放的资源(比如 BufferedReader)实现了 AutoCloseable 接口。有了解决方案之后,我们来对之前的 finally 代码块进行瘦身。

    try (BufferedReader br = new BufferedReader(new FileReader(decodePath));) {
        String str = null;
        while ((str =br.readLine()) != null) {
            System.out.println(str);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
    

    你瞧,finally 代码块消失了,取而代之的是把要释放的资源写在 try 后的 () 中。如果有多个资源(BufferedReader 和 PrintWriter)需要释放的话,可以直接在 () 中添加。

    try (BufferedReader br = new BufferedReader(new FileReader(decodePath));
         PrintWriter writer = new PrintWriter(new File(writePath))) {
        String str = null;
        while ((str =br.readLine()) != null) {
            writer.print(str);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
    

    如果你想释放自定义资源的话,只要让它实现 AutoCloseable 接口,并提供 close() 方法即可。

    public class TrywithresourcesCustom {
        public static void main(String[] args) {
            try (MyResource resource = new MyResource();) {
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    
    class MyResource implements AutoCloseable {
        @Override
        public void close() throws Exception {
            System.out.println("关闭自定义资源");
        }
    }
    

    代码运行后输出的结果如下所示:

    关闭自定义资源
    

    是不是很神奇?我们在 try () 中只是 new 了一个 MyResource 的对象,其他什么也没干,但偏偏 close() 方法中的输出语句执行了。想要知道为什么吗?来看看反编译后的字节码吧。

    class MyResource implements AutoCloseable {
        MyResource() {
        }
    
        public void close() throws Exception {
            System.out.println("关闭自定义资源");
        }
    }
    
    public class TrywithresourcesCustom {
        public TrywithresourcesCustom() {
        }
    
        public static void main(String[] args) {
            try {
                MyResource resource = new MyResource();
                resource.close();
            } catch (Exception var2) {
                var2.printStackTrace();
            }
    
        }
    }
    

    咦,编译器竟然主动为 try-with-resources 进行了变身,在 try 中调用了 close() 方法。

    接下来,我们在自定义类中再添加一个 out() 方法,

    class MyResourceOut implements AutoCloseable {
        @Override
        public void close() throws Exception {
            System.out.println("关闭自定义资源");
        }
    
        public void out() throws Exception{
            System.out.println("沉默王二,一枚有趣的程序员");
        }
    }
    

    这次,我们在 try 中调用一下 out() 方法:

    public class TrywithresourcesCustomOut {
        public static void main(String[] args) {
            try (MyResourceOut resource = new MyResourceOut();) {
                resource.out();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    

    再来看一下反编译的字节码:

    public class TrywithresourcesCustomOut {
        public TrywithresourcesCustomOut() {
        }
    
        public static void main(String[] args) {
            try {
                MyResourceOut resource = new MyResourceOut();
    
                try {
                    resource.out();
                } catch (Throwable var5) {
                    try {
                        resource.close();
                    } catch (Throwable var4) {
                        var5.addSuppressed(var4);
                    }
    
                    throw var5;
                }
    
                resource.close();
            } catch (Exception var6) {
                var6.printStackTrace();
            }
    
        }
    }
    

    这次,catch 块中主动调用了 resource.close(),并且有一段很关键的代码 var5.addSuppressed(var4)。它有什么用处呢?当一个异常被抛出的时候,可能有其他异常因为该异常而被抑制住,从而无法正常抛出。这时可以通过 addSuppressed() 方法把这些被抑制的方法记录下来。被抑制的异常会出现在抛出的异常的堆栈信息中,也可以通过 getSuppressed() 方法来获取这些异常。这样做的好处是不会丢失任何异常,方便我们开发人员进行调试。

    哇,有没有想到我们之前的那个例子——在 try-finally 中,readLine() 方法的异常信息竟然被 close() 方法的堆栈信息吃了。现在有了 try-with-resources,再来看看作用和 readLine() 方法一致的 out() 方法会不会被 close() 吃掉。

    close()out() 方法中直接抛出异常:

    class MyResourceOutThrow implements AutoCloseable {
        @Override
        public void close() throws Exception {
            throw  new Exception("close()");
        }
    
        public void out() throws Exception{
            throw new Exception("out()");
        }
    }
    

    调用这 2 个方法:

    public class TrywithresourcesCustomOutThrow {
        public static void main(String[] args) {
            try (MyResourceOutThrow resource = new MyResourceOutThrow();) {
                resource.out();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    

    程序输出的结果如下所示:

    java.lang.Exception: out()
    	at com.cmower.dzone.trycatchfinally.MyResourceOutThrow.out(TrywithresourcesCustomOutThrow.java:20)
    	at com.cmower.dzone.trycatchfinally.TrywithresourcesCustomOutThrow.main(TrywithresourcesCustomOutThrow.java:6)
    	Suppressed: java.lang.Exception: close()
    		at com.cmower.dzone.trycatchfinally.MyResourceOutThrow.close(TrywithresourcesCustomOutThrow.java:16)
    		at com.cmower.dzone.trycatchfinally.TrywithresourcesCustomOutThrow.main(TrywithresourcesCustomOutThrow.java:5)
    

    瞧,这次不会了,out() 的异常堆栈信息打印出来了,并且 close() 方法的堆栈信息上加了一个关键字 Suppressed。一目了然,不错不错,我喜欢。

    总结一下,在处理必须关闭的资源时,始终有限考虑使用 try-with-resources,而不是 try–catch-finally。前者产生的代码更加简洁、清晰,产生的异常信息也更靠谱。答应我好不好?别再用 try–catch-finally 了。

    觉得有点用记得给我点赞哦!😎

    简单介绍一下。我是沉默王二,一枚有趣的程序员。10 年前,当我上大学的时候,专业被调剂到了计算机网络,主修 Java 编程语言,但当时没怎么好好学(因为第一次接触计算机,感觉太难了),每年都要挂科两三门;因此工作后吃了不少亏。但是最近几年,情况发生了很大改变,你应该也能看得到我这种变化。通过坚持不懈地学习,持续不断地输出,我的编程基本功算得上是突飞猛进。

    为了帮助更多的程序员,我创建了“沉默王二”这个 ID,专注于分享有趣的 Java 技术编程和有益的程序人生。一开始,博客的阅读量寥寥无几,关注人数更是少得可怜。但随着影响力的逐步扩大,阅读量和关注人都在猛烈攀升。

    你在看这篇文章的时候,应该也能发现,我在 CSDN 上的总排名已经来到了第 71 位,这个排名还是非常给力的。有很多读者都说,我可以冲击第一名,我不愿意藏着掖着,我是有这个野心的。如果你也喜欢我的文章,请记得微信搜索「沉默王二」关注我的原创公众号,回复“1024”更有美团技术大佬整理的 Java 面试攻略相送,还有架构师的面试视频哦。绝对不容错过,期待与你的不期而遇。

    展开全文
  • Nginx的try_files指令详解

    千次阅读 2020-11-26 14:52:11
    在0.7以后的版本中加入了一个try_files指令,配合命名location,可以部分替代原本常用的rewrite配置方式,提高解析效率。 查看nginx手册 try_files 语法: try_files file ... uri 或 try_files file ... = code ...
  • Java 中 try-catch,throw和throws的使用

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

    千次阅读 2019-05-16 18:43:36
    try catch适用场合: 一、兼容性 浏览器的兼容性是程序员很头痛的事儿,往往一些出错会让我们查找许久,在使用try catch能更好的解决兼容性出错的问题:由于不同浏览器报错提示也不尽相同,通过使用try catch捕获的...
  • The PMP Exam How to Pass on Your First Try,国外版的一次性通过PMP考试,根据PMBOK第五版编辑,2013年出版
  • ABAP抓取异常的方法:try,endtry

    千次阅读 2018-07-19 11:24:11
    CLEARUP是在所在的TRY CATCH发生了异常,但在本TRY CATCH中无法捕获,异常再次向上递交给上层TRY CATCH前被执行的,它不同于Java中的finally PARAMETERS   number   TYPE   i . DATA  result  TYPE  p  ...
  • 文章目录1、异常1.1 异常概念1.2 异常体系1.3 异常分类1.4 异常的产生过程解析2、 异常的处理2.1 抛出异常throw2.2 Objects非空判断2.3 声明异常throws2.4 捕获异常try…catch2.4 finally 代码块2.5 异常注意事项3...
  • try catch finally 使用方法详解

    千次阅读 2019-03-18 14:20:54
    本文是一个老前辈写的java中的try、catch、finally的用法文章,下面的9个例子,把涵盖的所有用法基本都涵盖了,值得大家细细的观看,很有用。看完也就知道到底该怎么用try、catch了。希望对大家有所帮助。文末有我写...
  • Java基础之try-with-resource语法糖

    万次阅读 多人点赞 2020-12-22 11:41:20
    背景 在java开发中,一些网络链接或者...比如finalizer、try-catch-finally、try-with-resources等等。 try-with-resources try-with-resources是jdk1.7引入的语法糖,使得关闭资源操作无需层层嵌套在finally。 finali
  • Python中异常捕捉try..except...finally的使用

    万次阅读 多人点赞 2018-08-18 10:41:33
    3.如果在执行try子句的过程中发生了异常,那么try子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符,那么对应的except子句将被执行。最后执行 try 语句之外的代码。 #0.捕捉异常和不捕捉异常的...
  • a:try/except:拦截由Python或者自己的代码引起的异常并从中恢复。 很多人学习python,不知道从何学起。 很多人学习python,掌握了基本语法过后,不知道在哪里寻找案例上手。 很多已经做案例的人,却不知道如何去...
  • 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...
  • 到底怎样写 try-catch,才能称之为高手?

    千次阅读 多人点赞 2019-08-22 09:00:00
    try-catch,一个大家最常见不过的语法,但是有些人却用不好。当面对一个崩溃的时候,不管三七二十一先catch住再说,没错,老崩溃是被catch住了,但是新崩溃又出现...
  • C#_try语句

    万次阅读 2020-01-27 22:51:55
    try语句定义 try 语句提供一种机制,用于捕捉在块的执行期间发生的各种异常。此外,try 语句还能让您指定一个代码块,并保证当控制离开 try 语句时,总是先执行该代码。 try-statement: try block catch-clauses...
  • Scala Try 与错误处理

    千次阅读 2018-11-01 21:22:05
    一.概述 当你在尝试一门新的语言时,可能...事实会表明,Scala 能够很优雅的处理此类问题, 这一部分,我会介绍 Scala 基于 Try 的错误处理机制,以及这背后的原因。 我将使用一个在 Scala 2.10 新引入的特性,该...
  • 目录 一、绪论 (introduction) 二、异常捕获 (exception catching) 2.1 try-except 语句 2.1.1 基本用法 2.1.2 指定异常类型 2.1.3 小结 2.2 try-except-else 语句 2.3 try-except-else-finally 语句 2.4 小结 ...
  • try-with-resource:自动地关闭资源

    万次阅读 2019-01-08 19:37:45
    目录 一、资源关闭背景 二、JDK7之前的资源关闭方式 三、JDK7及其之后的资源关闭方式 3.1 try-with-resource语法 3.2 实现原理 3.3 异常抑制 3.4 try-with-resources语句中声明一个或多个资源 四、文件读取工具类 五...
  • android try catch并不影响性能

    千次阅读 2018-02-13 09:00:43
    今天,简单讲讲android里使用try--catch语句是否会影响性能。 我在app的代码里有一些for循环里面有try - catch语句,担心循环里一直执行try - catch语句会影响效率,所以在网上查询了资料,后来发现并不影响...
  • Golang try catch与错误处理

    万次阅读 2019-06-12 23:38:20
    Golang try catch 虽然在使用Golang的时候发现没有try catch这种错误处理机制但是想一想golang作为一门优雅的语言,似乎也是情理之中。因为在java中 throws在函数签名中有一个关键字,旨在使异常流程比较简洁,但是...
  • try catch 和throw以及throws的使用

    千次阅读 2019-04-13 17:08:25
    try-catch和throw,throws的区别 java里的异常多种多样,这是一种非常有用的机制,它能帮助我们处理那些我们未知的错误,在java里,关于异常的有throw throws,还有一个try catch 程序块。接下来我们挨个看看这几个的...
  • C# try-catch用法

    万次阅读 2018-10-12 16:54:06
    例子查询出错时,弹出对话框  private void cxBtn_Click(object sender, EventArgs e)//查询源启数据  {  try  {  s = dtpStatime.Value.Date.ToString().Replace('-', '/');  ...
  • ReentrantLock提供了lock()、tryLock()、tryLock(long timeout, TimeUnit unit)、lock.lockInterruptibly() 1)lock() public void lock() { sync.lock(); } 当锁可用,并且当前线程没有持有该锁,直接...
  • try except (异常捕获)

    千次阅读 2018-11-12 10:32:35
    try except (异常捕获) 当程序出错了,但是我们又不想让用户看到这个错误,而且我在写程序的时候已经预料到了它可以出现这样的错误,出现这样的错误代表着什么,我们可以提前捕获这些个错误 1、异常处理流程图: ...
  • C++中try--catch用法

    万次阅读 多人点赞 2018-07-28 09:56:04
    首先通过一个简单的例子来熟悉C++ 的 try/catch/throw(可根据单步调试来熟悉,try catch throw部分是如何运行的): #include #include "iostream" using namespace std; double fuc(double x, double y) //...
  • Python的try... excep异常捕捉机制

    千次阅读 2019-04-18 15:03:18
    Python的try... excep异常捕捉机制一、没有加入异常捕捉机制二、加入try ... except 异常捕捉1、已知错误类型 (例如下面已知列表索引错误类型`IndexError`)2、未知异常的类型三、try ... except ... else ... ...
  • python异常处理try-except语句

    千次阅读 2020-07-23 16:08:15
    1 为什么用try-except 语句 首先我们来说说,为什么要用try-except 语句。简单来说,为了避免程序意外退出,而需要使用的语句。 首先来看一段代码,你会更加容易理解: try: 1 / 0 except ZeroDivisionError: ...
  • java中try 与catch的使用

    万次阅读 多人点赞 2017-10-08 21:38:43
    try{ //代码区 }catch(Exception e){ //异常处理 } 代码区如果有错误,就会返回所写异常的处理。   首先要清楚,如果没有try的话,出现异常会导致程序崩溃。 而try则可以保证程序的正常运行下去,比如说: try{ int...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,378,904
精华内容 1,351,561
关键字:

try