版权声明：All right reserved 未经允许,禁止转载 https://blog.csdn.net/a308601801/article/details/88367649

Scala 中函数的定义

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

方法转换函数

[code]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
}
}

与过程的区别

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

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

惰性函数

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

[code]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  异常的种类

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

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

[code]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 表达式可以用在需要任何类型的地方

[code]def main(args: Array[String]): Unit = {

val res = test()
println(res.toString)
}

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

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