scala02--函数

和java也挺像的
不要return就可以返回

可变参数

这个java也有，差不多

  def main(args: Array[String]) {
    printStrings("Runoob", "Scala", "Python");
  }

  def printStrings(args: String*) = {
    for (arg <- args) {
      println(arg)
    }
  }

参数可以指定默认值

   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
   }

函数传名调用

可以理解为函数的参数是一个函数，也就是可以将函数的返回值当做参数

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

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

指定函数参数名

直接指定设置哪个参数的值了，不需要像java一样必须按照顺序了，感觉一般是和默认值搭配使用的

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 );
   }
}

匿名函数

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

偏应用函数

其实是匿名函数去调用函数的一种组合

  def main(args: Array[String]): Unit = {
    val t = test("aa", _: String)
    t("bb")
  }

  def test(a: String, b: String): Unit = {
    println(a + b)
  }

函数嵌套

感觉更改过多用于递归

  def main(args: Array[String]): Unit = {
    println(factorial(0))
  }

  //一般都有返回值
  def factorial(i: Int): Int = {
    def fact(i: Int, accumulator: Int): Int = {
      if (i <= 1)
        accumulator
      else
       //调用自己
        fact(i - 1, i * accumulator)
    }
    //调用这个内部函数
    fact(i, 1)
  }

递归

   def main(args: Array[String]) {
         println(factorial(7) )
   }
   
   def factorial(n: BigInt): BigInt = {  
      if (n <= 1)
         1  
      else    
      n * factorial(n - 1)
   }

高阶函数

Scala 中允许使用高阶函数, 高阶函数可以使用其他函数作为参数，或者使用函数作为输出结果。
把函数f和一个值v当做参数，内部可以用这个传过来的参数，这样就可以通过传入不同的参数而进行各种组合

   def main(args: Array[String]) {
      println( apply( layout, 10) )
   }
   // 函数 f 和 值 v 作为参数，而函数 f 又调用了参数 v
   def apply(f: Int => String, v: Int) = f(v)
   def layout[A](x: A) = "[" + x.toString() + "]"

函数柯里化(Currying)

def add(x:Int,y:Int)=x+y

可以这样写

def add(x:Int)=(y:Int)=>x+y

闭包

闭包通常来讲可以简单的认为是可以访问一个函数里面局部变量的另外一个函数。
如下面这段匿名的函数：

val multiplier = (i:Int) => i * 10  

函数体内有一个变量 i，它作为函数的一个参数。如下面的另一段代码：

val multiplier = (i:Int) => i * factor

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  
}