Scala函数 总结

• 主函数
• 函数的调用
• 函数的匹配
• 函数返回类型的设定
• 函数的递归
• 嵌套函数
• 偏应用函数
• 高阶函数
• 柯里化函数

---

object Fun {

  /**
    * 定义方法 def
    * 主函数必须用unit
    * 其他的函数中，返回值类型可加也可以不用加
    * @param args
    */
  def main(args: Array[String]): Unit = {
    /**
      * 返回最大值函数
      * @param x
      * @param y
      * @return
      */
    def max(x: Int, y: Int): Int = {
      if (x > y) {
        return x
      } else {
        return y
      }
    }

    println(max(100, 10))
    println("+++++++++++++++++++++++++++++++++++++++++++++++++++++")

    def max1(x: Int, y: Int): Int = {
      if (x > y)
        return x
      else
        return y
    }

    println(max1(100, 10))
    println("-----------------------------------------------------")

    /**
      * 不加等号返回值为空
      * 加上等号，不为空
      *
      * @param a
      */
    def fun(a: String): Unit = {
      "dadadadada------->" + a
    }

    println(fun("sss"))
    println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")

    def fun1(b: String) = {
      "dadadader------->" + b
    }

    println(fun1("sss"))
    println("+++++++++++++++++++++++++++++++++++++++++++++++++++++++")

    def fun2(c: String) {
      "dadadader------->" + c
    }

    println(fun2("sss"))
    println("------------------------------------------------------")

    /**
      * 递归
      * @param s
      * @return
      */
    def fun3(s: Int): Int = {
      if (s == 1) {
        1
      } else {
        s * fun3(s - 1)
      }
    }

    println(fun3(5))
    println("`````````````````````````````````````````````````````````")

    /**
      * 默认值函数
      *
      * @param e
      * @param f
      * @return
      */
    def fun4(e: Int = 100, f: Int = 200): Int = {
      e + f
    }

    println(fun4(10))
    println(fun4())
    val p = fun4(_: Int, 800)
    println(p(200))

    println("_________________________________________________________________")

    /**
      * 加不加括号一样
      *
      * @param ss
      */
    def fun5(ss: String*) = {
      ss.foreach(s => {
        println(s)
      })
    }

    fun5("a", "b", "c", "d")
    println("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@")

    def fun6(ss: String*) = {
      ss.foreach((s) => {
        println(s)
      })
    }

    fun6("a", "b", "c", "d")

    println("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$")

    /**
      * 嵌套函数
      *
      * @param num
      * @return
      */
    def fun7(num: Int): Int = {
      def fun8(a: Int): Int = {
        if (a == 1) {
          a
        } else {
          a * fun8(a - 1)
        }
      }

      fun8(num)
    }

    println(fun7(5))
    println("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")

    /**
      * 部分参数应用函数(偏应用函数)
      *
      * @param date
      * @param log
      */
    def showInfo(date: Date, log: String) = {
      println("data is " + date + ",log is " + log)
    }

    val date1 = new Date()
    showInfo(date1, "a")
    showInfo(date1, "b")
    showInfo(date1, "c")
    val fun9 = showInfo(date1: Date, _: String)
    fun9("aaa")
    fun9("bbb")
    fun9("ccc")
    println("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")

    /**
      * 高阶函数
      * 1.函数的参数是函数
      * 2.函数的返回值是函数
      * 3.函数的参数和返回值都是函数
      *
      * @param f
      * @param x
      * @return
      */
    //函数的参数势函数
    def fun10(f: (Int, Int) => String, x: Int): String = {
      val result = f(100, 200)
      result + "@" + x
    }

    val result = fun10((a: Int, b: Int) => {
      a + "~" + b
    }, 100)
    println(result)
    println("==================================================================")

    /**
      * 函数的返回值是函数，需要显示声明方法的返回值类型是函数
      *
      * @param a
      * @param b
      * @return
      */
    def fun11(a: Int, b: Int): (Int, Int) => Int = {
      val result = a + b

      //result=3
      def fun12(x: Int, y: Int): Int = {
        x + y + result
      }

      fun12
    }

    println(fun11(1, 2)(100, 200))

    println("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^")

    /**
      * 函数的参数和返回值都是函数
      * @param f
      * @return
      */
    def fun13(f: (Int, Int) => Int): (String, String) => String = {
      val result = f(1, 2)

      def fun14(s1: String, s2: String): String = {
        s1 + "#" + s2 + "**" + result
      }

      fun14
    }

    println(fun13((a: Int, b: Int) => {
      a + b
    })("hello", "who are you"))

    println("#################################################################")

    /**
      * 柯里化函数
      * @param a
      * @param b
      * @param c
      * @param d
      * @return
      */
    def fun15(a:Int,b:Int)(c:Int,d:Int)={
      a+b+c+d
    }
    println(fun11(1,2)(3,4))

  }
}