函数介绍
-
scala语言
Scala语言是一个完全面向对象编程语言。万物皆对象
Scala语言是一个完全函数式编程语言。万物皆函数
-
函数和方法的区别
函数：为完成某一功能的程序指令（语句）的集合，称为函数。
方法：类中的函数称之方法。
函数声明
-
函数声明
（1）函数1：无参，无返回值
（2）函数2：无参，有返回值
（3）函数3：有参，无返回值
（4）函数4：有参，有返回值
（5）函数5：多参，无返回值
-
实例
object FuncDeclare {def main(args: Array[String]): Unit = {// 函数1：无参，无返回值def test(): Unit = {println("无参，无返回值")}test()// 函数2：无参，有返回值def test2(): String = {"无参，有返回值"}println(test2())// 函数3：有参，无返回值def test3(s: String): Unit = {println(s)}test3("有参，无返回值")// 函数4：有参，有返回值def test4(s: String): String = {s + "有参，有返回值"}println(test4("有参，有返回值 "))// 函数5：多参，无返回值def test5(name: String, age: Int): Unit = {println(s"$name, $age")}test5("多参", 40)}}
函数参数
-
说明
（1）可变参数
（2）如果参数列表中存在多个参数，那么可变参数一般放置在最后
（3）参数默认值
（4）带名参数
-
实例
object FuncTest {def main(args: Array[String]): Unit = {// （1）可变参数def test( s : String * ): Unit = {println(s)}test("Hello", "Scala")test()// (2)如果参数列表中存在多个参数，那么可变参数一般放置在最后def test2( name : String, s: String* ): Unit = {println(name + "," + s)}test2("参数", "可变参数1","可变参数2")// (3)参数默认值def test3( name : String, age : Int = 30 ): Unit = {println(s"$name, $age")}// 如果参数传递了值，那么会覆盖默认值test3("参数默认值", 20)// 如果参数有默认值，在调用的时候，可以省略这个参数test3("参数默认值")def test4( sex : String = "男", name : String ): Unit = {println(s"$name, $sex")}// scala函数中参数传递是，从左到右// 一般情况下，将有默认值的参数放置在参数列表的后面//test4("带名参数")//（4）带名参数test4(name="带名参数")}}
函数至简原则
函数至简原则：能省则省
（1）return可以省略，Scala会使用函数体的最后一行代码作为返回值
（2）返回值类型如果能够推断出来，那么可以省略
（3）如果函数体只有一行代码，可以省略花括号
（4）如果函数无参，则可以省略小括号。
若定义函数时省略小括号，则调用该函数时，也需省略小括号；
若定时函数时未省略，则调用时，可省可不省。
（5）如果函数明确声明Unit，那么即使函数体中使用return关键字也不起作用
（6）Scala如果想要自动推断无返回值，可以省略等号
（7）如果不关心名称，只关系逻辑处理，那么函数名（def）可以省略
（8）如果函数明确使用return关键字，那么函数返回就不能使用自行推断了，需要声明返回值类型
object FuncTest {def main(args: Array[String]): Unit = {// 0）函数标准写法def f1(s: String): String = {return s + " 函数标准写法"}println(f1("Hello"))//（1） return可以省略,scala会使用函数体的最后一行代码作为返回值def f2(s: String): String = {s + " return可以省略"}println(f2("Hello"))// 如果函数名使用return关键字，那么函数就不能使用自行推断了,需要声明返回值类型/* def f2(s:String)={return "Hello"}*///（2）返回值类型如果能够推断出来，那么可以省略def f3(s: String) = {s + " f3"}println(f3("f3"))//（3）如果函数体只有一行代码，可以省略花括号//def f4(s:String) = s + " Hello"//def f4(s:String) = "Hello"def f4() = " f4()"// 如果函数无参，但是声明参数列表，那么调用时，小括号，可加可不加。println(f4())println(f4)//（4）如果函数没有参数列表，那么小括号可以省略,调用时小括号必须省略def f5 = "f5"// val f5 = "Hello"println(f5)//（5）如果函数明确声明unit，那么即使函数体中使用return关键字也不起作用def f6(): Unit = {//return "abc""Hello"}println(f6())//（6）scala如果想要自动推断无返回值,可以省略等号// 将无返回值的函数称之为过程def f7() {"Hello"}println(f7())//（7）如果不关心名称，只关系逻辑处理，那么函数名（def）可以省略//()->{println("xxxxx")}val f = (x: String) => x + "Hello"// 万物皆函数 : 变量也可以是函数println(f("f()"))//（8）如果函数明确使用return关键字，那么函数返回就不能使用自行推断了,需要声明返回值类型def f8(): String = {return "f8()"}println(f8())}}
高阶函数
-
说明
定义：参数为函数的函数称为高阶函数
-
案例实操
object FuncTest {def main(args: Array[String]): Unit = {//高阶函数————函数作为参数def calculator(a: Int, b: Int, operater: (Int, Int) => Int): Int = {operater(a, b)}//函数————求和def plus(x: Int, y: Int): Int = {x + y}//方法————求积def multiply(x: Int, y: Int): Int = {x * y}//函数作为参数println(calculator(2, 3, plus))println(calculator(2, 3, multiply))}}
匿名函数
没有名字的函数就是匿名函数，可以直接通过函数字面量（表达式）来设置匿名函数
object FuncTest {//高阶函数————函数作为参数def calculator(a: Int, b: Int, operator: (Int, Int) => Int): Int = {operator(a, b)}//函数————求和def plus(x: Int, y: Int): Int = {x + y}def main(args: Array[String]): Unit = {//函数作为参数println(calculator(2, 3, plus))//匿名函数作为参数println(calculator(2, 3, (x: Int, y: Int) => x + y))//匿名函数简写形式println(calculator(2, 3, _ + _))}}
函数柯里化&闭包
-
说明
函数柯里化：将一个接收多个参数的函数转化成一个接受一个参数的函数过程，可以简单的理解为一种特殊的参数列表声明方式。
闭包：就是一个函数和与其相关的引用环境（变量）组合的一个整体(实体)
-
实例
object FuncTest {def main(args: Array[String]): Unit = {//外部变量var x: Int = 10//闭包def f( y: Int): Int = {x + y}// 40println(f(30))}}
object FuncTest {val sum = (x: Int, y: Int, z: Int) => x + y + zval sum1 = (x: Int) => {y: Int => {z: Int => {x + y + z}}}val sum2 = (x: Int) => (y: Int) => (z: Int) => x + y + zdef sum3(x: Int)(y: Int)(z: Int) = x + y + zdef main(args: Array[String]): Unit = {sum(1, 2, 3)sum1(1)(2)(3)sum2(1)(2)(3)sum3(1)(2)(3)}}
控制抽象
Scala中可以自己定义类似于if-else，while的流程控制语句，即所谓的控制抽象。
scala中，以下结构称为代码块（block），可视为无参函数，作为 =>Unit类型的参数值。
{code}
object FuncTest {def loop(n: Int)(op: => Unit): Unit = {if (n > 0) {oploop(n - 1)(op)}}def main(args: Array[String]): Unit = {loop(5) {println("test")}}}
惰性函数
-
说明
当函数返回值被声明为lazy时，函数的执行将被推迟，直到我们首次对此取值，该函数才会执行。这种函数我们称之为惰性函数。
-
案例实操
object FuncTest {def main(args: Array[String]): Unit = {lazy val res = sum(10, 30)println("----------------")println("res=" + res)}def sum(n1: Int, n2: Int): Int = {println("sum被执行。。。")return n1 + n2}}
注意：lazy不能修饰var类型的变量
