5.函数函数一切都是函数

函数函数

函数基础

在Scala中，Scala是一个完全的函数编程语言，因此在Scala中一切皆是函数，在类中的函数就是方法，Scala的语法灵活，可以在任意的语法结构嵌套语法结构，函数没有重载和重写的概念，因此不能有同名函数，但是方法可以重写

   def test:Unit ={
            println("fds")
        }
        // 调用函数
        // 函数名（参数）
        test

函数的定义

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

        // 1. 函数无参数，无返回值

        def f1(): Unit ={
            println("f1...")
        }
        f1()
        // 2. 函数有参数，无返回值
        def f2(name : String): Unit ={
            println(s"name = $name")
        }
        f2("fsa")

        // 3. 函数有参数，有返回值
        def f3(i:Int):Int={
            return  i+10
        }
        println(f3(10))
        // 4. 函数无参数，有返回值
        def f4(): String={
            return "213"
        }
        println(f4())

        // 5.函数有多个参数，有返回值
        def f5(i :Int, j:Int):Int={
            return  i +j
        }
       println(f5(10,20))

       // 6. 函数的返回值类型不确定
        // Scala采用至简原则简化函数的声明：越简单越好
        def f6(b :Boolean):Any={
            if(b){
                return  1
            }else{
                return "123"
            }
        }

        // 7.可变参数
        def f7(i:Int *):Unit={
            println(i)
        }
        f7(123,4213,53)

        // 7,1.可变参数,有多个参数时，可变参数不能放在前面一般放在最后
        def f71(j:String,i:Int *):Unit={
            for (k :Int<-i)
            println(k)
        }
        f71("",4213,53)

        // 8.参数默认值,函数的所有参数都默认声明为val.
        def f8( name :String = "默认值"): Unit ={
            println(s"name=$name")
        }
        f8()

        // 9.多个值，但是name用默认值，Scala中的参数的匹配规则是从左到右,
        // 在处理以下情况时通过传参数时把名称带上，可以实现
        def f9( name :String = "默认值", age:Int): Unit ={
            println(s"name=$name")
        }

        f9(age=30)

    }

函数至简单原则

  def main(args: Array[String]): Unit = {
       def main(args: Array[String]): Unit = {
        //(0) 标准

        def f1(i :Int) : String = {
            return i+""
        }

        //（1）return可以省略，Scala会使用函数体的最后一行代码作为返回值
        def f2(i :Int) : String = {
             i+""
        }

        //（2）如果函数体只有一行代码，可以省略花括号
        def f3(i :Int) : String =
            i+""

        //（3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）
        def f4(i:Int)={
            i+""
        }

        //（4）如果有return，则不能省略返回值类型，必须指定
//        def f5(i:Int)={
//           return i+""
//        }
        def f5 (i:Int) :String ={
            return  i+""
        }

        //（5）如果函数明确声明Unit，那么即使函数体中使用return关键字也不起作用
        def f6 (i:Int) :Unit ={
            return  i+""
        }
        f6(12)

        //（6）Scala如果期望是无返回值类型，可以省略等号
            def f7(): Unit ={
                
            }

        //（7）如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加

                def f8() = "dalang7"
                println(f8())
                println(f8)

        //（8）如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略
            def f9 : String = {
                "sad"
            }

        //（9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略

        (x:Int,y:Int)=>x+y



    }

        //至简原则: 能省就省
        def f1 () : String={
            "fsa"
        }

        //TODO 1 如果在当前的场合下可以推断出函数的返回值类型,返回值可以省略
        // 一般函数中不需要使用return语法,函数可以根据满足条件的最后一行代码作为返回值
        def f2()={
            val flag = true
            if(flag){
                12
            }else
                {
                    "zaneSan"
                }
        }

        // TODO 2如果函数体只要一行代码,那么花括号可以省掉

        def f3() = "zhangSan"

        //TODO 3 如果函数中没有参数列表无参,那么参数列表可以省略
        // 如果省略小括号,那么调用时也不能写小括号,为了实现统一访问原则,类似于变量访问
        def f4 = "zaneSan"
        println(f4)
        // 类似于以下情况
        val name = "asd"
        println(name)
        //println(f4())

        // TODO 4 如果想要省略Unit,又不想使用最后一行代码作为返回值,等号可以省略
        // 如果函数返回值使用Unit,函数不会采用最后一行代码作为返回值,
        //
        def f5() {"dsa"}

        // TODO 5 如果不关心函数的名称,只关心函数的实现省略函数名,使用匿名函数
        // 匿名函数可以赋值给变量,通过变量来调用
        val f6 = ()=>{println("匿名函数")}
            f6()

函数的高级使用

def main(args: Array[String]): Unit = {
        //至简原则: 能省就省
        // Scala是完全面向函数的,所以万物皆函数
        // 函数什么都可以做:可以作为变量,可以昨晚参数,可以返回值
        def f1() : Unit={
            println("wqe")
        }

        // 如果函数没有参数,那么在调用时,可以不使用小括号
        // 如果想要把函数作为一个整体传递给变量.可以使用下划线
        // TODO 1 函数作为变量，要加下划线
        // 自动推断类型，需要加下划线
        val f = f1 _
        // 声明变量类型
        val f : () => unit = f1
        // 打印function1,表示有一个参数,scala中的参数最多只有22个
        println(f)
        // 变量就可以作为函数使用
        f()

        // TODO 2 函数作为参数
        // 对于函数来讲，最重要的是：函数名，函数的输入，函数的输出
        // 函数的参数也可以是参数: 函数( 函数名:函数类型)
        // 函数类型:(参数列表)=>返回值类型
        def f2( fPara : (Int,Int)=>Int) :Int={
            fPara(10,10)
        }

        def f22(i:Int,j:Int) :Int={
            i+j
        }
        f2(f22)
        // 使用匿名函数省略
        // 如果匿名函数中参数类型可以推断,那么也可以胜略
        println(f2((x,y)=>{x+y}))
        //如果函数式逻辑至尊一行代码,那么函数体的花括号可以省略
        println(f2((x,y)=>x+y))
        // 如果参数只使用一次,而且有顺序,那么可以省略参数,可以使用下划线代替指定位置的参数,再省
        println(f2(_+_))
    }