def max(a: Int, b: Int) = {
  if (a > b) {
    "哈哈"
  } else {
    b
  }
}
// 語法糖: 方法定義
def max0(a: Int, b: Int) = if (a > b) a else b

def fun2(num: Int): Int = {
  if (num == 1)
    num
  else
    num * fun2(num - 1)
}
// 語法糖
def fun2(num:Int) : Int = if (num == 1) num else num * fun2(num - 1)

def fun3(a: Int = 10, b: Int) = {
  println(a + b)
}

def fun4(elements: Int*) = {
  println(elements)
  elements.foreach(i => println(i))
  // 當匿名函數(shù)的元素只用到一次的時候, 可以用_簡寫
  elements.foreach(println(_))
  // 當方法入?yún)閱蝹€參數(shù)時且正好是匿名函數(shù)的元素時, 進一步簡寫
  elements.foreach(println)
  var sum = 0;
  for (elem <- elements) {
    sum += elem
  }
  sum
}

/**
 * 原生的匿名函數(shù)寫法(基本不用)
 * @return
 */
def fun: (Int, Int) => Int = (a: Int, b: Int) => {
  a + b
}

/**
 * 常用的匿名函數(shù)寫法: 可以將匿名函數(shù)返回給定義的一個變量, 看到“=>”就是匿名函數(shù)
 * 多用于方法的參數(shù)是函數(shù)時(函數(shù)指針),用匿名函數(shù)簡寫
 *
 * @param args
 */
def main(args: Array[String]): Unit = {
  /**
   * 有參數(shù)匿名函數(shù)
   */
  val value1: (Int) => Unit = (a: Int) => {
    println(a)
  }
  value1(1)
  /**
   * 無參數(shù)匿名函數(shù)
   */
  val value2 = () => {
    println("我愛學習")
  }
  value2()
  /**
   * 有返回值的匿名函數(shù)
   */
  val value3 = (a: Int, b: Int) => {
    a + b
  }
  println(value3(4, 4))
}

/**
 * 嵌套方法
 * 例如：嵌套方法求5的階乘
 */
def fun5(num: Int) = {
  def fun6(a: Int, b: Int): Int = {
    if (a == 1) {
      b
    } else {
      fun6(a - 1, a * b)
    }
  }
  fun6(num, 1)
}

def showLog(date :Date, log :String)= {
  println(s"date is $date, log is $log")
}
def main(args: Array[String]): Unit = {
  val date = DateUtil.date(new Date())
  showLog(date,"當前時間")
  // 想要調(diào)用log, 以上變化的是第二個參數(shù), 可以用偏應用函數(shù)處理
  // 把showLog()方法定義為偏應用函數(shù)
  val logWithDate = showLog(date,_:String)
  // 第二種函數(shù)寫法
  def logWithDate2 = showLog(date,_:String)
  logWithDate("偏應用函數(shù)-log11")
  logWithDate("偏應用函數(shù)-log22")
  logWithDate("偏應用函數(shù)-log33")
}

  /**
   * 普通的方法
   *
   * @param a
   * @param b
   * @return
   */
  def fun(a: Int, b: Int): Int = {
    a + b
  }
  /**
   * 使用 _把方法強轉為一個函數(shù)
   */
  private val function: (Int, Int) => Int = fun _
  /**
   * 函數(shù)的參數(shù)是函數(shù): 函數(shù)的類型 (Int, Int) => Int, 記住: 方法的引用僅為方法本身,需要重新賦實參
   *
   * @param f 函數(shù)作為參數(shù)
   * @param a
   * @return
   */
  def fun1(f: (Int, Int) => Int, a: Int): Int = {
    f(a, 100)
  }
  /**
   * 函數(shù)的返回是函數(shù): 必須要顯示地寫出返回值類型, 或者使用 f2 _
   *
   * @param a
   * @param b
   * @return
   */
  def fun2(a: Int, b: Int): (Int, Int) => Int = {
    // 在內(nèi)部定義了一個方法
    def f2(v1: Int, v2: Int): Int = {
      v1 + v2 + a + b
    }
    f2
  }
  /**
   * 函數(shù)的參數(shù)是函數(shù),函數(shù)的返回是函數(shù)
   *
   * @param f
   * @return
   */
  def fum3(f: (Int, Int) => Int): (String, String) => String = {
    val i = f(1, 2)
    def fun1(s1: String, s2: String): String = {
      s1 + "@" + s2 + "$" + i
    }
    fun1
  }
  /**
   * 函數(shù)入口
   *
   * @param args
   */
  def main(args: Array[String]): Unit = {
    // 顯示聲明過的函數(shù)作為參數(shù)
    println("顯示聲明過的函數(shù)作為參數(shù): " + fun1(fun, 100))
    // 匿名函數(shù)作為參數(shù): 匿名函數(shù)入?yún)⒌念愋涂梢允÷圆粚?
    println("匿名函數(shù)作為參數(shù): " + fun1((a: Int, b: Int) => {
      a * b
    }, 100))
    // 返回值是一個函數(shù)
    println("返回值是一個函數(shù): " + fun2(1, 2)(3, 4))
    // 入?yún)⒑统鰠⒍际呛瘮?shù)
    println("入?yún)⒑统鰠⒍际呛瘮?shù): " + fum3(fun)("hello", "scala!"))
    println("入?yún)⒑统鰠⒍际呛瘮?shù): " + fum3((a, b) => a * b)("hello", "scala!"))
  }

def fun7(a: Int, b: Int)(c: Int, d: Int) = {
  a + b + c + d
}
/**
 * 函數(shù)入口
 *
 * @param args
 */
def main(args: Array[String]): Unit = {
  println(fun7(1, 2)(3, 4))
}