try-catch-finally注记

1. throw也是有结果类型的表达式，它返回Nothing，我们知道它是所有引用类型的子类
2. 使用catch捕获异常，语法是模式匹配，即catch { case e:Exception => ...}，如果都无法解决则继续上抛
3. 可以在方法签名后使用throws声明cheched exception，但不是必须的
4. try-catch也产生值，catch捕获到异常在处理时，可以返回一个值作为整个表达式的返回值
5. finally中的语句无论如何都会执行，但是返回值却不一定在finally中
6. 在Java中，finally里面使用return显式返回一个值或抛出的异常，将“凌驾”于任何之前源于try代码块或某个它的catch子句产生的值或异常之上
7. 在Scala中，我们考虑以下下几种情况：

没有return关键字

def test:Int=try{
        println("try")
        1
    }finally{
        println("finally")
        2
    }

scala> test
try
finally
res14: Int = 1

def test:Int=try{
        println("try")
        1
        throw new Exception
        2
    }catch{
        case e:Exception=>{
        println("catch")
        3
    }
    }finally{
        println("finally")
        4
    }

scala> test
try
catch
finally
res0: Int = 3

有return关键字

def test:Int=try{
        println("try")
        1
    }finally{
        println("finally before return")
        return 2  //注意，如果在scala里显式使用return，则函数必须写明返回值
        println("finally after return")
    }

scala> test
try
finally before return
res16: Int = 2

def test:Int=try{
        println("try")
        return 1
    }finally{
        println("finally before return")
        return 2
        println("finally after return")
    }

scala> test
try
finally before return
res1: Int = 2

def test:Int=try{
        println("try")
        1
        throw new Exception
        2
    }catch{
        case e:Exception=>{
            println("catch")
            3
        }
    }finally{
        println("finally before return")
        return 4
        println("finally after return")
    }

scala> test
try
catch
finally before return
res3: Int = 4

def test:Int=try{
        println("try")
        1
        throw new Exception
        2
    }catch{
        case e:Exception=>{
            println("catch")
            return 3
        }
    }finally{
        println("finally before return")
        4
    }

scala> test
try
catch
finally before return
res4: Int = 3

def test:Int=try{
        println("try")
        return 1
        throw new Exception
        2
    }catch{
        case e:Exception=>{
            println("catch")
            return 3
        }
    }finally{
        println("finally before return")
        return 4
        println("finally after return")
    }

scala> test
try
catch
finally before return
res5: Int = 4

指明与不指明返回类型

（注意，因为如果含有return语句就必须写明返回类型，这就是上面的情况，所以以下只考虑没有return的情况）

def test:Int=try{
        println("try")
    }catch{
        case e:Exception=>{
        println("catch")
    }
    }finally{
        println("finally")
        4
    }

:12: error: type mismatch;
 found   : Unit
 required: Int
               println("try")
                      ^
:15: error: type mismatch;
 found   : Unit
 required: Int
               println("catch")
                      ^

def test=try{                  //未标明返回类型
        println("try")
        1                        //try“可能”返回Int
    }catch{    
        case e:Exception=>{
        println("catch")   //Catch“可能”返回Unit
    }
    }finally{
        println("finally")
        4
    }

scala> test
try
finally
res30: AnyVal = 1    //注意到返回值类型是AnyVal而不是Int

def test=try{      //未标明返回类型
        println("try")
        1          //try“可能”返回Int
    }catch{
        case e:Exception=>{
        println("catch")
        2         //Catch“可能”返回Int
    }
    }finally{
        println("finally")
        4
    }

scala> test
try
finally
res37: Int = 1    //注意返回类型是Int而不是上面的AnyVal

可以发现，在try-catch-finally结构中

• 如果有finally，则finally里的语句一定执行

• 如果方法标明返回类型，则会同时检查catch和try的返回类型是否符合要求，这是因为，如果没有抛出异常，则try将返回值（当然如果finally有return语句，则finally将会返回），如果抛出异常，则catch会返回，所以二者都有可能，也就都要检查了。

• 如果没有声明返回类型，则返回类型将会是catch和try的返回类型的公共父类，例如，一个是Int一个是Unit，则返回类型是AnyVal

• 如果没有 return语句，则无异常时try返回，否则catch返回，无论如何finally不返回

• 如果有 return，则将返回最后一个 return的内容。

参考：

1. 学习Scala：使用try-catch表达式处理异常
2. 理解贷出模式 Loan Pattern