Scala与Java差异（三）之函数

柔光的暖阳◎ 2022-12-23 03:28 144阅读 0赞

### 一、函数定义 ###

**（1）函数的定义与调用**

在Scala中定义函数时，需要定义函数的函数名、参数、函数体。

第一个函数如下所示：

def sayHello(name: String, age: Int) = {
    
      if (age > 18) { printf("hi %s, you are a big boy\n", name); age }
    
      else { printf("hi %s, you are a little boy\n", name); age
    
    }
    
    sayHello("leo", 30)

Scala要求必须给出所有参数的类型，但是不一定给出函数返回值的类型，只要右侧的函数体中不包含递归的语句，Scala就可以自己根据右侧的表达式推断出返回类型。

** （2）在代码块中定义包含多行语句的函数体**

单行的函数：def sayHello(name: String) = print("Hello, " + name)

如果函数体中有多行代码，则可以使用代码块的方式包裹多行代码，代码块中最后一行的返回值就是整个函数的返回值。与Java中不同，不是使用return返回值的。

比如如下的函数，实现累加的功能：

def sum(n: Int) = {
    
      var sum = 0;
    
      for(i <- 1 to n) sum += i
    
      sum
    }

**（3）递归函数与返回类型**

如果在函数体内递归调用函数自身，则必须手动给出函数的返回类型。

例如，实现经典的斐波那契数列：

9 + 8; 8 + 7 + 7 + 6; 7 + 6 + 6 + 5 + 6 + 5 + 5 + 4; ....

def fab(n: Int): Int = {
    
      if(n <= 1) 1
    
      else fab(n - 1) + fab(n - 2)
    
    }

### 二、函数的默认参数和带名参数 ###

**（1） 默认参数**

在Scala中，有时我们调用某些函数时，不希望给出参数的具体值，而希望使用参数自身默认的值，此时就定义在定义函数时使用默认参数。

def sayHello(firstName: String, middleName: String = "William", lastName: String = "Croft") = firstName + " " + middleName + " " + lastName

如果给出的参数不够，则会从作往右依次应用参数。

**（2）Java与Scala实现默认参数的区别**

Java：

public void sayHello(String name, int age) {
    
      if(name == null) {
    
        name = "defaultName"
    
      }
    
      if(age == 0) {
    
        age = 18
    
      }
    
    }
    
    sayHello(null, 0)

Scala：

def sayHello(name: String, age: Int = 20) {
    
      print("Hello, " + name + ", your age is " + age)
    
    }
    
    sayHello("leo")

**（3）带名参数**

在调用函数时，也可以不按照函数定义的参数顺序来传递参数，而是使用带名参数的方式来传递。

sayHello(firstName = "Mick", lastName = "Nina", middleName = "Jack")

还可以混合使用未命名参数和带名参数，但是未命名参数必须排在带名参数前面。

sayHello("Mick", lastName = "Nina", middleName = "Jack")

### 三、函数的变长参数 ###

**（1）变长参数**

在Scala中，有时我们需要将函数定义为参数个数可变的形式，则此时可以使用变长参数定义函数。

def sum(nums: Int*) = {
    
      var res = 0
    
      for (num <- nums) res += num
    
      res
    
    }
    
    sum(1, 2, 3, 4, 5)

**（2）使用序列调用变长参数**

在如果想要将一个已有的序列直接调用变长参数函数，是不对的。比如val s = sum(1 to 5)。此时需要使用Scala特殊的语法将参数定义为序列，让Scala解释器能够识别。这种语法非常有用！一定要好好注意，在spark的源码中大量地使用到了。

val s = sum(1 to 5: _*)

案例：使用递归函数实现累加

def sum2(nums: Int*): Int = {
    
      if (nums.length == 0) 0
    
      else nums.head + sum2(nums.tail: _*)

### 四、函数的过程、lazy值和异常 ###

**（1）过程**

在Scala中，定义函数时，如果函数体直接包裹在了花括号里面，而没有使用=连接，则函数的返回值类型就是Unit。这样的函数就被称之为过程。过程通常用于不需要返回值的函数。

过程还有一种写法，就是将函数的返回值类型定义为Unit。

def sayHello(name: String) = "Hello, " + name
    
    def sayHello(name: String) { print("Hello, " + name); "Hello, " + name }
    
    def sayHello(name: String): Unit = "Hello, " + name

**（2）lazy值**

在Scala中，提供了lazy值的特性，也就是说，如果将一个变量声明为lazy，则只有在第一次使用该变量时，变量对应的表达式才会发生计算。这种特性对于特别耗时的计算操作特别有用，比如打开文件进行IO，进行网络IO等。

import scala.io.Source._
    
    lazy val lines = fromFile("C://Users//Administrator//Desktop//test.txt").mkString

即使文件不存在，也不会报错，只有第一个使用变量时会报错，证明了表达式计算的lazy特性。

val lines = fromFile("C://Users//Administrator//Desktop//test.txt").mkString
    
    lazy val lines = fromFile("C://Users//Administrator//Desktop//test.txt").mkString
    
    def lines = fromFile("C://Users//Administrator//Desktop//test.txt").mkString

**（3） 异常**

在Scala中，异常处理和捕获机制与Java是非常相似的。

try {
    
      throw new IllegalArgumentException("x should not be negative")
    
    } catch {
    
      case _: IllegalArgumentException => println("Illegal Argument!")
    
    } finally {
    
      print("release resources!")
    
    }

try {
    
      throw new IOException("user defined exception")
    
    } catch {
    
      case e1: IllegalArgumentException => println("illegal argument")
    
      case e2: IOException => println("io exception")
    
    }