Scala函数基础

本文详细介绍了Java编程中的函数定义、参数处理(包括可变参数、默认值和带名参数)、至简原则的应用、高阶函数(如函数作为值和参数传递、返回值)、匿名函数和闭包的概念,以及递归的使用。同时提到了Java面试中的常见知识点和准备策略。
摘要由CSDN通过智能技术生成

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门,即可获取!

}

函数定义


说明

(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

}

最后总结我的面试经验

2021年的金三银四一眨眼就到了,对于很多人来说是跳槽的好机会,大厂面试远没有我们想的那么困难,摆好心态,做好准备,你也可以的。

另外,面试中遇到不会的问题不妨尝试讲讲自己的思路,因为有些问题不是考察我们的编程能力,而是逻辑思维表达能力;最后平时要进行自我分析与评价,做好职业规划,不断摸索,提高自己的编程能力和抽象思维能力。

BAT面试经验

实战系列:Spring全家桶+Redis等

其他相关的电子书:源码+调优

面试真题:


《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门,即可获取!
tln(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

}

最后总结我的面试经验

2021年的金三银四一眨眼就到了,对于很多人来说是跳槽的好机会,大厂面试远没有我们想的那么困难,摆好心态,做好准备,你也可以的。

另外,面试中遇到不会的问题不妨尝试讲讲自己的思路,因为有些问题不是考察我们的编程能力,而是逻辑思维表达能力;最后平时要进行自我分析与评价,做好职业规划,不断摸索,提高自己的编程能力和抽象思维能力。

[外链图片转存中…(img-ek5DiirD-1714744123632)]

BAT面试经验

实战系列:Spring全家桶+Redis等

[外链图片转存中…(img-1tSfcpKA-1714744123632)]

其他相关的电子书:源码+调优

[外链图片转存中…(img-Nt6WnSZ6-1714744123632)]

面试真题:

[外链图片转存中…(img-Ojdj5kNw-1714744123633)]

[外链图片转存中…(img-9sRKvMLP-1714744123633)]
《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门,即可获取!

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值