scala-函数式编程

Scala 语言是一个完全面向对象编程语言。万物皆对象

对象的本质：对数据和行为的一个封装

函数式编程

解决问题时，将问题分解成一个一个的步骤，将每个步骤进行封装（函数），通过调用这些封装好的步骤，解决问题。

例如：请求->用户名、密码->连接 JDBC->读取数据库Scala 语言是一个完全函数式编程语言。万物皆函数。函数的本质：函数可以当做一个值进行传递

在Scala 中函数式编程和面向对象编程完美融合在一起了。

函数基础

函数基本语法

案例实操

需求：定义一个函数，实现将传入的名称打印出来。

object TestFunction {

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

        // （1）函数定义
        def f(arg: String): Unit = {
 
        println(arg)
    }
    
        // （2）函数调用
        // 函数名（参数）
        f("hello world")
    }
}


// 输出
hello world

函数和方法的区别

 核心概念

        为完成某一功能的程序语句的集合，称为函数。

        类中的函数称之方法。

案例实操

        Scala 语言可以在任何的语法结构中声明任何的语法

        函数没有重载和重写的概念；方法可以进行重载和重写

        Scala 中函数可以嵌套定义

object TestFunction {

    // (2)方法可以进行重载和重写，程序可以执行
    def main(): Unit = {

    }

    def main(args: Array[String]): Unit = {
        // （1）Scala 语言可以在任何的语法结构中声明任何的语法
        import java.util.Date 
        new Date()

        // (2)函数没有重载和重写的概念，程序报错
        def test(): Unit ={
            println("无参，无返回值")
        }
        test()

        def test(name:String):Unit={ 
            println()
        }

        //（3）Scala 中函数可以嵌套定义
        def test2(): Unit ={
             println("函数可以嵌套定义")
            }
        }
    }
}



无参，无返回值
函数可以嵌套定义

函数定义

函数 1：无参，无返回值

函数 5：多参，无返回值

函数 4：有参，有返回值

函数 3：有参，无返回值

函数 2：无参，有返回值

函数 6：多参，有返回值

package com.zpark.chapter05 

object TestFunctionDeclare {

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


        // 函数 1：无参，无返回值
        def test1(): Unit ={

            println("无参，无返回值")

        }

        test1()



        // 函数 2：无参，有返回值
        def test2():String={

            return "无参，有返回值"

        }

        println(test2())



        // 函数 3：有参，无返回值

        def test3(s:String):Unit={ 
            println(s)

        }

        test3("scala")


    
        // 函数 4：有参，有返回值
        def test4(s:String):String={ 
            return s+"有参，有返回值"
        }
        println(test4("hello "))



        // 函数 5：多参，无返回值
        def test5(name:String, age:Int):Unit={ 
            println(s"$name, $age")
        }
        test5("dalang",40)




        // 函数 6：多参，有返回值
        def test6(name: String, age: Int): String = {
            val message = s"$name is$age years old"
            message
        }

        // 调用函数6并打印返回值
        val result = test6("dalang", 40)
        println(result)

函数至简原则（重点）

函数至简原则：能省则省

原则细节

return可以省略，Scala 会使用函数体的最后一行代码作为返回值

如果函数体只有一行代码，可以省略花括号

返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）

如果有 return，则不能省略返回值类型，必须指定

如果函数明确声明unit，那么即使函数体中使用 return 关键字也不起作用

Scala 如果期望是无返回值类型，可以省略等号

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

如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略

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

函数高级

高阶函数

可以定义函数，调用函数

object TestFunction {

    def main(args: Array[String]): Unit = {
        // 调用函数
        foo()
    }
    // 定义函数
    def foo():Unit = { 
        println("foo...")
    }

 更高阶的有

1. 函数可以作为值进行传递
2. 函数可以作为参数进行传递
3. 函数可以作为函数返回值返回

匿名函数

没有名字的函数就是匿名函数。（就相当于偷偷做好事，人家问是不是你，你不承认）

(x:Int)=>{函数体}

x：表示输入参数类型；Int：表示输入参数类型；函数体：表示具体代码逻辑2）案例实操

需求 1：传递的函数有一个参数传递匿名函数至简原则：

参数的类型可以省略，会根据形参进行自动的推导

类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过 1 的永远不能省略圆括号。

匿名函数如果只有一行，则大括号也可以省略

如果参数只出现一次，则参数省略且后面参数可以用_代替

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

    // （1）定义一个函数：参数包含数据和逻辑函数
    def operation(arr: Array[Int], op: Int => Int) = 
        { for (elem <- arr) yield op(elem)
    }

    // （2）定义逻辑函数
    def op(ele: Int): Int = 
        { ele + 1
    }

    // （3）标准函数调用
    val arr = operation(Array(1, 2, 3, 4), op)
     println(arr.mkString(","))

    // （4）采用匿名函数
    val arr1 = operation(Array(1, 2, 3, 4), (ele: Int) => { 
        ele + 1
    })


    // （4.1）参数的类型可以省略，会根据形参进行自动的推导; 
    val arr2 = operation(Array(1, 2, 3, 4), (ele) => {
        ele + 1
    })
    println(arr2.mkString(","))


    // （4.2）类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过 1 的永远不能省略圆括号。
    val arr3 = operation(Array(1, 2, 3, 4), ele => {
         ele + 1
    })
    println(arr3.mkString(","))


    // (4.3) 匿名函数如果只有一行，则大括号也可以省略
    val arr4 = operation(Array(1, 2, 3, 4), ele => ele + 1) 
    println(arr4.mkString(","))


    //（4.4）如果参数只出现一次，则参数省略且后面参数可以用_代替
    val arr5 = operation(Array(1, 2, 3, 4), _ + 1)
     println(arr5.mkString(","))
    }
}

跟Python中的匿名函数还是有些区别的：

        格式：

                lambda 形参1，形参2：函数体 

                （lambda a,b:a+b）(1,2)

1. 一般只有一行表达式，必须有返回值
2. 匿名函数没有return
3. 可以有一个或多个参数