大数据---------spark体系之分布式计算---------scala分布式编程开发语言----------scala函数（04,05）

问题集锦

---

正文

    /**
      * 递归函数
      * 递归函数必须制定函数的返回值类型
      */
    def fun(num:Int) :Int = {
      if(num == 1)
        num
      else{
        num * fun(num - 1)
      }
    }
    println(fun(3))

    /**
      * 参数有默认值的函数
      */
    def fun1(x:Int=8,y:Int=10) = {
      x*y
    }
    println(fun1(3,5))

    /**
      * 可变长参数的函数
      */
    def fun2(emmu :String*)={
      emmu.foreach(s=>{
        println(s)
      })
    }
    fun2("a","b","c")

    /**
      * 匿名函数
      */
    val fun3=()=>{//无参数匿名函数
      println(23)
    }
    fun3()//匿名函数就是这样调用的

    val fun4 = (a:Int,b:Int)=>{
      a*b
    }
    fun4(5,6)//给匿名函数传递参数


    /**
      * 嵌套函数
      */
    def fun5(a:Int) = {//功能是计算a的阶乘

      def fun6(x:Int):Int = {
        if(x == 1)
          x
        else {
          x*fun6(x-1)
        }
      }
      fun6(5)

    }
    println(fun5(5))


    /**
      * 偏应用函数
      */
    def showlog(d:Date,log:String)={
      println("Date is " + d + "log is " + log)
    }
    val date = new Date()
    val sl = showlog(date:Date,_:String)//以上是偏应用函数的定义部分

    sl("aaa")//这里是偏应用函数的调用部分，和匿名函数的调用部分很像
    sl("bbb")
    sl("ccc")


    /**
      * 高阶函数 一共有3类
      * 1.函数的参数是函数
      * 2.函数的返回是函数  这种类型的高阶函数必须显式的定义它的返回值 函数的返回值是函数 这种返回值的写法和匿名函数的写法十分相近。
      * 3.函数的参数和返回都是函数
      */
    //函数的参数是函数
    def fun6(a:Int,b:Int):Int={
      a+b
    }
    def fun7(s:String,f:(Int,Int)=>Int)={//注意这里的参数的写法，f:(Int,Int)=>Int   f的后面有个冒号，进来两个Int，出去一个Int。
      val result = f(100,200)
      s + " " + result
    }
    println(fun7("hello ",fun6))//注意这里高阶函数的调用，fun7中fun6作为一个参数，但是不能给fun6传递参数的。如果需要给fun6传递参数，那么就在高阶函数里面调用.比如下面这种调用方法就是错误的。
   // fun7("lisa",fun6(20,30))


    //函数的返回值是函数  这个函数的基本形式不同于函数的参数是函数的那种类型，它的基本形式是一个嵌套函数。
    def fun8(a:Int,b:Int):(String,String)=>String={
      def fun9(s1:String,s2:String):String = {
         s1 + " " + s2
      }
      a*b
      fun9
    }
    //函数的调用
    fun8(12,13)("peng","wanli")


    //函数的参数和函数的返回值都是函数


    def fun10(f:(Int,Int)=>Int):(String,String)=>String={
      val result1=  f(6,10)
      def fun11(s1:String,s2:String):String={
        s1+ " " + s2 + "  " + result1
      }
      fun11
    }
    //调用  如果函数作为参数，则给它传递参数是在（将它作为参数的）函数的内部。对它的调用是以将它作为参数传递给别的函数来实现的。
    // 如果函数作为返回值，则给它传递参数是在外部调用（将它作为返回值的）函数的时候。
    //
   println(fun10(fun6)("xu","shuai"))


    /**
      * 柯里化函数
      * 柯里化函数是高阶函数中的返回值是函数这种类型的简化版 。它的调用方式和高阶函数中的返回值是函数这种类型是一样的。
      */
    def fun12(a:Int,b:Int)(c:Int,d:Int)={
      a+b+c+d
    }
    println(fun12(1,2)(3,4))

 

 

---