Sgg：Scala基础语法（下）

scala 定义函数的标准格式为：

def 函数名(参数名 1: 参数类型 1, 参数名 2: 参数类型 2) : 返回类型 = {函数体}

1 函数有返回值

  //如果使用return 必须指明返回类型
  def test1():String = {
    return "abc"
  }

  //如果不使用return，那么不必声明返回类型
  def test2() = {
    "abc"
  }

注： Scala 中的函数可以根据函数体最后一行代码自行推断函数返回值类型。那么在这种情况下， return 关键字可以省略，既然 Scala 可以自行推断，所以在省略 return 关键字的场合，返回值类型也可以省略。如果函数明确使用 return 关键字，那么函数无法省略返回值类型。

2 函数无返回值

注：如果函数明确声明无返回值（声明 Unit） ，那么函数体中即使使用 return 关键字
也不会有返回值。
如果明确函数无返回值或不确定返回值类型，那么返回值类型可以省略

  def test4()={
    val a = 10
    if(a > 10){
      100
    }else{
      "10"
    }
  }

3 函数有参数

注：函数如果参数列表不为空，那么在调用时需要传递参数，不能省略，这和 JavaScript语法不一样，在 JavaScript 中调用有参函数时，如果没有传递参数，那么参数会自动赋值为 undefined, Scala 也可以实现类似的功能， 就是在声明参数时，直接赋初始值。
一个带参数的函数如下：

  def test5(p : String)={
    println(p)
  }

声明函数的参数时候加默认值：

  def test5(p : String = "zhang3")={
    println(p)
  }

调用函数时，如果不传递参数，就采用默认的初始值，如果传递参数，传递的参数会覆盖初始化。
让我们运行这个调用方法的代码：

  def main(args: Array[String]): Unit = {
    test5()
    test5("li4")
  }

zhang3
li4

Process finished with exit code 0

如果函数存在多个参数， 每一个参数都可以设定默认值， 那么这个时候，传递的参数到底是覆盖默认值，还是赋值给没有默认值的参数，就不确定了(默认按照声明顺序)。在这种情况下，可以采用带名参数
下面这个函数有两个参数：

  def test6(n:String="zhangfei" , a:Int)= {
    println("n:"+n+",a:"+a)
  }

然后调用，其中参数a使用带名参数传入：

    test6("li4",100)  //正常声明参数调用
    test6(a = 10) //不声明n，n使用函数的默认值，a值自行传入

运行结果为：

n:li4,a:100
n:zhangfei,a:10

Process finished with exit code 0

有了带名参数传入的方式，甚至我们不需要考虑 传入的参数顺序：

test6(a = 50,n = "wang5")

运行结果为：

n:wang5,a:50

Process finished with exit code 0

4 变长参数

（不确定个数参数，类似 Java 的…）

	//不定长参数的用法
  def test7(nums:Int*)= {
    var sum = 0
    for(i <- nums){
      sum += i
    }
    sum
  }

    println(test7() )
    println(test7(1))
    println(test7(1,2,3,4,5))

0
1
15

Process finished with exit code 0

5 递归函数

• 递归是把一个复杂问题转化成很多个相同的小问题的。而且递归要明确终止条件。
• 递归函数未执行之前是无法推断出来结果类型， 在使用时必须有明确的返回值类型
• 简简单单安排个小阶乘：

  def test8(n:Int): Int ={
    if ( n == 1) 1 else n*test8(n-1)
  }

println(test8(3))

6

Process finished with exit code 0

6 过程

将函数的返回类型为 Unit 的函数称之为过程。如果明确函数没有返回值，那么等号可以省略

7 惰性函数

• 当函数返回值被声明为 lazy 时，函数的执行将被推迟，直到我们首次对此取值。 这种函数我们称之为惰性函数，在 Java 的某些框架代码中称之为懒加载（延迟加载）
• 通俗的讲：什么时候用到这个函数的返回结果了，什么时候真的执行这个函数。
• 非立即执行的函数。

  def test10()= {
    println("test10 方法执行")
    "test10"
  }

    lazy val msg = test10()
    println("test10 方法没有执行")
    println(msg)

test10 方法没有执行
test10 方法执行
test10

Process finished with exit code 0