}

函数定义


说明

(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 n a m e , m y a g e i s {name},my age 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开发的新手,还是希望在技术上不断提升的资深开发者,这些资料都将为你打开新的学习之门!

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

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

Logo

欢迎加入西安开发者社区!我们致力于为西安地区的开发者提供学习、合作和成长的机会。参与我们的活动,与专家分享最新技术趋势,解决挑战,探索创新。加入我们,共同打造技术社区!

更多推荐