Scala 优雅入门 (四) 函数式编程

Scala 中函数的定义

def 函数名 ([参数名: 参数类型], ...)[[: 返回值类型] =] {
    语句... //完成某个功能
    return 返回值
}

方法转换函数

main {
    //创建对象
    val dog = new Dog
    println(dog.sum(10,20))

    //方法转成函数
    val f1 = dog.sum _
    println("f1=" + f1)
    println("f1=" + f1(50,60))

    //定义函数, 求两个数的和
    val f2 = (n1:Int,n2:Int) => {
        n1 + n2 //函数体
    }
}

class Dog {
    //方法
    def sum(n1:Int,n2:Int): Int = {
        n1 + n2
    }
}

与过程的区别

//函数foo返回值类型为Unit,说明没有返回值
//这个函数我们也叫过程
def foo(name: String): Unit = {
    println(name + " hello")
}

//过程的等号可以省略
def foo(name: String) {
    println(name + " hello")
}

惰性函数

惰性计算（尽可能延迟表达式求值）延迟计算是许多函数式编程语言的特性, 能够得到更高效的代码

def main(args: Array[String]): Unit = {
    lazy val res = sum(1,2)
    println("-----------------------")
    println("res=" + res) //当需要使用到res时，就会真正的开始计算
}

def sum(n1:Int,n2:Int): Int = {
    println("sum 被调用..")
    n1 + n2
}

注意: 

1. lazy 不能修饰 var 类型的变量
2. 在调用函数时，加了 lazy ,会导致函数的执行被推迟，在声明一个变量时，如果加了 lazy ,那么变量值得分配也会推迟。 比如 lazy val i = 10

异常处理

Scala 提供 try 和 catch 块来处理异常, 在 try 中使用模式匹配

在 catch 中，可以有多个 case ，对可能的异常进行匹配

case ex: Exception => println("异常信息=" + ex.getMessage)

case 是一个关键字

ex: Exception  异常的种类

=> 表明后的代码是对异常进行处理, 如果处理的代码有多条语句可以 { } 括起来

如果捕获异常，代码即使出现异常，程序也不会崩溃, 而是继续向下执行

try {
    var res = 10 / 0
} catch {
    case ex: ArithmeticException => {
        println("算术异常=" + ex.getMessage)
        println("111")
    }
    case ex: Exception => println("异常信息=" + ex.getMessage)
} finally {
    println("finaly的代码...")
}
println("程序继续....")

//输出结果
---------------------
算术异常=/ by zero
111
finaly的代码...
程序继续....

如果要抛出一个异常对象, 可以使用 throw 关键字。

所有异常都是 Throwable 的子类型。

throw 表达式是有类型的，为Nothing，因为Nothing 是所有类型的子类型，所以 throw 表达式可以用在需要任何类型的地方

def main(args: Array[String]): Unit = {
    
    val res = test()
    println(res.toString)
}

def test(): Nothing = {
    throw new Exception("异常")
}

Scala 优雅入门 (五) 面向对象