函数与闭包（十三）

简介

Scala 有方法与函数，二者在语义上的区别很小。Scala 方法是类的一部分，而函数是一个对象可以赋值给一个变量。换句话来说在类中定义的函数即是方法。
我们这里会统称为函数。

Scala 中的函数是一个继承了 Trait类的对象。函数定义由一个 def 关键字开始，紧接着是可选的参数列表，一个冒号 : 和方法的返回类型，一个等号 = ，最后是方法的主体。

def functionName ([参数列表]) : [return type]

如果没有等号和方法主体，那么函数会被隐式声明为抽象(abstract)。

基本函数

//将两个传入的参数相加并求和
object add{
   def addInt( a:Int, b:Int ) : Int = {
      var sum:Int = 0
      sum = a + b

      return sum
   }
}

//如果没有返回值，可返回Unit类型
object Hello{
   def printMe( ) : Unit = {
      println("Hello, Scala!")
   }
}

//函数调用
object Test {
   def main(args: Array[String]) {
        println( "Returned Value : " + addInt(5,7) );
   }
   def addInt( a:Int, b:Int ) : Int = {
      var sum:Int = 0
      sum = a + b

      return sum
   }
}

函数传名调用

scala解释器在解析函数参数时有两种方式

传值调用（call-by-value）：先计算参数表达式的值，再应用到函数内部
传名调用（call-by-name）：将未计算的参数表达式直接应用到函数内部，每次使用传名调用时，解释器都会计算一次表达式的值。

object Test {
   def main(args: Array[String]) {
        delayed(time());
   }

   def time() = {
      println("获取时间，单位为纳秒")
      System.nanoTime
   }
   def delayed( t: => Long ) = {
      println("在 delayed 方法内")
      println("参数： " + t)
      t
   }
}

函数指定参数名

一般情况下函数调用参数，就按照函数定义时的参数顺序一个个传递。但也可以通过指定函数参数名，并且不需要按照顺序向函数传递参数，实例如下：

object Test {
   def main(args: Array[String]) {
        printInt(b=5, a=7);
   }
   def printInt( a:Int, b:Int ) = {
      println("Value of a : " + a );
      println("Value of b : " + b );
   }
}

可变参数

Scala 通过在参数的类型之后放一个星号来设置可变参数。

object Test {
   def main(args: Array[String]) {
        printStrings("Runoob", "Scala", "Python");
   }
   def printStrings( args:String* ) = {
      var i : Int = 0;
      for( arg <- args ){
         println("Arg value[" + i + "] = " + arg );
         i = i + 1;
      }
   }
}

默认参数值

Scala 可以为函数参数指定默认参数值，使用了默认参数，在调用函数的过程中可以不需要传递参数，这时函数就会调用它的默认参数值，如果传递了参数，则传递值会取代默认值。实例如下：

object Test {
   def main(args: Array[String]) {
        println( "返回值 : " + addInt() );
   }
   def addInt( a:Int=5, b:Int=7 ) : Int = {
      var sum:Int = 0
      sum = a + b

      return sum
   }
}

匿名函数

scala 中定义匿名函数的语法很简单，箭头左边是参数列表，右边是函数体。比如，

var inc = (x:Int) => x+1

闭包

闭包是一个函数，返回值依赖于声明在函数外部的一个或多个变量。

object Test {  
   def main(args: Array[String]) {  
      println( "muliplier(1) value = " +  multiplier(1) )  
      println( "muliplier(2) value = " +  multiplier(2) )  
   }  
   var factor = 3  
   val multiplier = (i:Int) => i * factor  
}