}

函数定义

---

说明

（1）函数 1：无参，无返回值

（2）函数 2：无参，有返回值

（3）函数 3：有参，无返回值

（4）函数 4：有参，有返回值

（5）函数 5：多参，无返回值

（6）函数 6：多参，有返回值

案例实操

package chapter05

object Test02_FunctionDefine {

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

// （1）函数 1：无参，无返回值

def function1(): Unit = {

println(“函数 1：无参，无返回值”)

}

println(function1())

println(“========================”)

// （2）函数 2：无参，有返回值

def function2(): Int = {

println(“函数 2：无参，有返回值”)

return 12

}

println(function2())

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

def function3(name: String): Unit ={

println("函数 3：有参，无返回值 " + name)

}

println(function3(“alice”))

println(“========================”)

// （4）函数 4：有参，有返回值

def function4(name: String): String ={

println("函数 3：有参，无返回值 " + name)

return “Hi alice”

}

println(function4(“Alice”))

println(“========================”)

// （5）函数 5：多参，无返回值

def function5(name1: String, name2: String): Unit = {

println(name1 +“和”+ name2 + “是好朋友”)

}

println(function5(“alice”,“bob”))

println(“========================”)

// （6）函数 6：多参，有返回值

def function6(name1: String, name2: String): String = {

println(name1 +“和”+ name2 + “是好朋友”)

return “是好朋友”

}

println(function6(“alice”,“bob”))

}

}

函数参数

---

说明

（1）可变参数

（2）如果参数列表中存在多个参数，那么可变参数一般放置在最后

（3）参数默认值，一般将有默认值的参数放置在参数列表的后面

（4）带名参数

案例实操

package chapter05

object Test03_FunctionParameter {

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

// （1）可变参数

def function1(str: String*): Unit ={

println(str)

}

function1(“alice”)

function1(“alice”,“alice1”,“alice2”)

// （2）如果参数列表中存在多个参数，那么可变参数一般放置在最后

def function2(str1: String, str: String*): Unit ={

println(str1,str)

}

function2(“alice”,“alice1”)

function2(“alice”,“alice1”,“alice2”)

// （3）参数默认值，一般将有默认值的参数放置在参数列表的后面

def function3(name: String = “atguigu”): Unit ={

println(“我的名字是”+name)

}

function3()

function3(“test”)

// （4）带名参数

def function4(name: String, age: Int): Unit ={

println(s"my name is $name,myageis${age}")

}

function4(“alice”,20)

function4(age = 10, name = “bob”)

}

}

函数至简原则

---

说明

函数至简原则即能省则省

至简原则的细节

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

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

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

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

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

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

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

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

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

案例实操

package chapter05

object Test03_FunctionSimplify {

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

def function1(name: String): String = {

return name

}

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

def function2(name: String): String = {

name

}

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

def function3(name: String): String = name

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

def function4(name: String) = name

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

def function5(name: String): String = return name

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

def function6(name: String): Unit = {

return name

}

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

def function7(name: String){

return name

}

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

def function8(): Unit ={

println(“无参数”)

}

function8()

function8

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

def function9: Unit ={

println(“无参数”)

}

// function9() //error

function9

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

(name: String) => { //匿名函数，lambda表达式

println(name)

}

}

}

函数高级

---

高阶函数

在 Scala 中，函数是一等公民。怎么体现的呢？

对于一个函数我们可以：定义函数、调用函数 ，但是其实函数还有更高阶的用法 .

(1)函数可以作为值进行传递

(2)函数可以作为参数进行传递

(3)函数可以作为函数返回值返回

案例实操

package chapter05

object Test06_HighOrderFunction {

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

def function1(n: Int): Int = {

println(“function1调用”)

n + 1

}

def function2(): Int = {

println(“function2调用”)

1

}

val result: Int = function1(123)

println(result)

//函数作为值传递

val f1 = function1(_)

val f2: Int => Int = function1

println(f1)

println(f2)

println(f1(12))

println(f2(13))

val f3 = function2

val f5:() => Int = function2

val f4 = function2 _

println(f3)

println(f4)

println(f5)

//函数作为函数的参数进行传递

//定义一个二元计算函数

def dualEval(op: (Int,Int) => Int, a: Int, b: Int): Int ={

op(a,b)

}

def add(a:Int, b:Int): Int = {

a + b

}

println(dualEval(add, 12, 13))

println(dualEval((a, b) => a + b , 12, 13))

println(dualEval(_+ _ , 12, 13))

//函数作为函数的返回值返回

def function5(): Int => Unit = {

def function6(a: Int): Unit ={

println("调用function6 " + a )

}

function6

}

val f6 = function5()

println(f6)

println(function5())

println(f6(25))

}

}

匿名函数

---

说明

没有名字的函数就是匿名函数。

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

x：表示输入参数类型；Int：表示输入参数类型；函数体：表示具体代码逻辑

案例实操

传递匿名函数至简原则：

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

（2）类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参

数超过 1 的永远不能省略圆括号。

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

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

package chapter05

object Test05_Lambda {

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

val fun = (name: String) => { //匿名函数，lambda表达式

println(name)

}

fun(“atguigu”)

//定义一个函数，以函数作为输入

def function(func: String => Unit): Unit ={

func(“atguigu”)

}

function(fun)

function((name: String) => {println(name)})

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

function((name) => {println(name)})

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

function( name => {println(name)})

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

function( name => println(name))

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

function(println(_))

//（5）如果可以推断出，当前传入的println是一个函数体，而不是调用语句，可以直接省略下划线

function(println)

//实际示例，定义一个二元函数，只操作1和2两个数，但具体运算通过参数传入

def dualFUnctionOneAndTwo(fun: (Int, Int) => Int): Int ={

fun(1,2)

}

val add = (a: Int, b: Int) => a + b

val minus = (a: Int, b: Int) => a - b

println(dualFUnctionOneAndTwo(add))

println(dualFUnctionOneAndTwo(minus))

//匿名函数简化

println(dualFUnctionOneAndTwo((a: Int, b: Int) => a + b))

println(dualFUnctionOneAndTwo((a: Int, b: Int) => a - b))

println(dualFUnctionOneAndTwo((a,b) => a + b))

println(dualFUnctionOneAndTwo(_ + _))

}

}

函数柯里化&闭包

---

说明

闭包：函数式编程的标配

闭包：如果一个函数，访问到了它的外部（局部）变量的值，那么这个函数和他所处的

环境，称为闭包

函数柯里化：把一个参数列表的多个参数，变成多个参数列表。

案例实操

package chapter05

object Test09_ClosureAndCurrying {

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

def add(a:Int, b: Int): Int = {

a + b

}

//考虑固定一个加数的场景

def addByFour(b:Int): Int ={

b + 4

}

//扩展固定加数改变的情况

def addByFive(b: Int): Int ={

5 + b

}

//将固定加数作为另外一个参数输入，但是作为第一层参数输入

def addByFour1(): Int => Int = {

val a = 4

def addB(b:Int): Int ={

b + a

}

addB

}

//分层调用(闭包应用)

def addBya(a: Int): Int => Int = {

def addB(b:Int): Int ={

b + a

}

addB

}

println(addBya(12)(23))

val addByFour2 = addBya(4)

val addByFive2 = addBya(5)

println(addByFive2(12))

println(addByFour2(12))

//简写

def addBya2(a: Int): Int => Int = {

{ b => b + a}

}

//简写

def addBya3(a: Int): Int => Int = _ + a

//柯里化(底层是闭包)

def addCurrying(a: Int)(b: Int): Int ={

a + b

}

println(addCurrying(2)(3))

}

}

递归

---

说明

一个函数/方法在函数/方法体内又调用了本身，我们称之为递归调用

案例实操

package chapter05

import scala.annotation.tailrec

object Test10_Recursion {

//递归调用

def fact(i: Int): Int = {

if (i == 0) return 1

fact(i-1) * i

}

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

递归

---

说明

一个函数/方法在函数/方法体内又调用了本身，我们称之为递归调用

案例实操

package chapter05

import scala.annotation.tailrec

object Test10_Recursion {

//递归调用

def fact(i: Int): Int = {

if (i == 0) return 1

fact(i-1) * i

}

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-OwkLgldu-1714952394173)]

[外链图片转存中…(img-nQprwFel-1714952394174)]

[外链图片转存中…(img-1FVr9Kqw-1714952394174)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！