Scala——函数

import java.util.Date
import java.util.concurrent.atomic.DoubleAccumulator

/**
  * Created by vincentliu on 7/17/2017.
  */
object HelloWorld {

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

    println("=======函数传名调用=======")
    delayed(time())
    println("=======指定函数参数名=======")
    printInt(b = 1, a = 10)
    println("=======可变参数=======")
    printStrings("Runoob", "Scala", "Python")
    println("=======递归函数=======")
    for (i <- 1 to 10)
      println(i + "的阶乘为：" + factorial(i))
    println("========默认参数值======")
    println("返回值：" + addInt(b = 1));
    println("========高阶函数======")
    println(apply(layout, 10))
    println("========函数嵌套======")
    println(factorial(6))

    // 匿名函数
    println("=========匿名函数=====")
//    var inc = (x: Int) => x+1
    var inc = new Function1[Int, Int]{
      def apply(x: Int):Int = x + 1
    }
    println(inc(2))

    // 偏应用函数
    println("=======偏应用函数=====")
    var date = new Date()
    log(date, "message1")
    var logWithDateBound = log(date, _ : String)
    logWithDateBound("message2")

    // 函数柯里化
    println("========函数柯里化=====")
    println(strcat("hello, ")(" scala!"))
  }

  /**
    * 函数传名调用
    * @return
    */
  def time() = {
    println("获取时间，单位为纳秒")
    System.nanoTime()
  }

  def delayed(t: => Long) = {
    println("在delayed方法内")
    println("参数：" + t)
    t
  }

  /**
    * 指定函数参数名
    * @param a
    * @param b
    */
  def printInt(a:Int, b:Int) = {
    println("Value of a : " + a)
    println("Value of b : " + b)
  }

  /**
    * 可变参数
    * @param args
    */
  def printStrings( args:String* ) = {
    var i : Int = 0
    for( arg <- args){
      println("Arg value[" + i + "] = " + arg)
      i = i + 1
    }
  }

  /**
    * 递归函数
    * @param n
    * @return
    */
  def factorial(n: BigInt): BigInt = {
    if (n <= 1)
      1
    else
      n * factorial(n - 1)
  }

  /**
    *   默认参数值
    * @param a
    * @param b
    * @return
    */
  def addInt(a:Int = 5, b:Int = 7) : Int = {
    var sum:Int = 0
    sum = a + b
    return sum
  }

  /**
    *   高阶函数 （高阶函数可以使用其他函数作为参数，或者使用函数作为输出结果
    *   函数 f 和 值 v 作为参数，而函数 f 又调用了参数v
    * @param f
    * @param v
    * @return
    */

  def apply(f: Int => String, v: Int) = f(v)    //  第一个Int是指定函数f的参数类型, String是指函数f的返回类型,
  def layout[A](x: A) = "[" + x.toString() + "]"

  /**
    *  函数嵌套
    * @param i
    * @return
    */
  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)
  }

  /**
    * 偏应用函数
    * @param date
    * @param message
    */
  def log(date: Date, message: String) = {
    println(date + "-----" + message)
  }

  /**
    * 函数柯里化
    * @param s1
    * @param s2
    * @return
    */
  def strcat(s1: String)(s2:String) = {
    s1 + s2
  }
}