2021-2022年寒假学习进度09
今天学习了scala的函数式编程
函数式编程
1 函数基础
1.1 函数基本语法
1）基本语法
2）案例实操
需求：定义一个函数，实现将传入的名称打印出来。
|
def main(args: Array[String]): Unit = {
// （1）函数定义
def f(arg: String): Unit = {
println(arg)
}
// （2）函数调用
// 函数名（参数）
f("hello world")
}
|
1.2 函数和方法的区别
1）核心概念
（1）为完成某一功能的程序语句的集合，称为函数。
（2）类中的函数称之方法。
2）案例实操
（1）Scala 语言可以在任何的语法结构中声明任何的语法
（2）函数没有重载和重写的概念；方法可以进行重载和重写
（3）Scala 中函数可以嵌套定义
|
object Test {
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 ={
def test3(name:String):Unit={
println("函数可以嵌套定义")
}
}
}
}
|
1.3 函数定义
1）函数定义
（1）函数 1：无参，无返回值
（2）函数 2：无参，有返回值
（3）函数 3：有参，无返回值
（4）函数 4：有参，有返回值
（5）函数 5：多参，无返回值
（6）函数 6：多参，有返回值
2）案例实操
|
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("jinlian")
// 函数 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)
}
|
1.4 函数参数
（1）可变参数
（2）如果参数列表中存在多个参数，那么可变参数一般放置在最后
（3）参数默认值，一般将有默认值的参数放置在参数列表的后面
（4）带名参数
|
def main(args: Array[String]): Unit = {
// （1）可变参数，不确定参数数量时使用可变参数
def test( s : String* ): Unit = {
println(s)
}
// 有输入参数：输出 Array
test("Hello", "Scala")
// 无输入参数：输出 List()
test()
// (2)如果参数列表中存在多个参数，那么可变参数一般放置在最后
def test2( name : String, s: String* ): Unit = {
println(name + "," + s)
}
test2("jinlian", "dalang")
// (3)参数默认值
def test3( name : String, age : Int = 30 ): Unit = {
println(s"$name, $age")
}
// 如果参数传递了值，那么会覆盖默认值
test3("jinlian", 20)
// 如果参数有默认值，在调用的时候，可以省略这个参数
test3("dalang")
// 一般情况下，将有默认值的参数放置在参数列表的后面
def test4( sex : String = "男", name : String ): Unit = {
println(s"$name, $sex")
}
// Scala 函数中参数传递是，从左到右
//test4("wusong")
//（4）带名参数
test4(name="ximenqing")
}
|
1.5 函数至简原则（重点）
函数至简原则：能省则省
1）至简原则细节
（1）return 可以省略，Scala 会使用函数体的最后一行代码作为返回值
（2）如果函数体只有一行代码，可以省略花括号
（3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）
（4）如果有 return，则不能省略返回值类型，必须指定
（5）如果函数明确声明 unit，那么即使函数体中使用 return 关键字也不起作用
（6）Scala 如果期望是无返回值类型，可以省略等号
（7）如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加
（8）如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略
（9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略
2）例
|
def main(args: Array[String]): Unit = {
// （0）函数标准写法
def f( s : String ): String = {
return s + " jinlian"
}
println(f("Hello"))
// 至简原则:能省则省
//（1） return 可以省略,Scala 会使用函数体的最后一行代码作为返回值
def f1( s : String ): String = {
s + " jinlian"
}
println(f1("Hello"))
//（2）如果函数体只有一行代码，可以省略花括号
def f2(s:String):String = s + " jinlian"
//（3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起 省略）
def f3( s : String ) = s + " jinlian"
println(f3("Hello3"))
//（4）如果有 return，则不能省略返回值类型，必须指定。
def f4() :String = {
return "ximenqing4"
}
println(f4())
//（5）如果函数明确声明 unit，那么即使函数体中使用 return 关键字也 不起作用
def f5(): Unit = {
return "dalang5"
}
println(f5())
//（6）Scala 如果期望是无返回值类型,可以省略等号
// 将无返回值的函数称之为过程
def f6() {
"dalang6"
}
println(f6())
//（7）如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可 不加
def f7() = "dalang7"
println(f7())
println(f7)
//（8）如果函数没有参数列表，那么小括号可以省略,调用时小括号必须省 略
def f8 = "dalang"
//println(f8())
println(f8)
//（9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略
def f9 = (x:String)=>{println("wusong")}
def f10(f:String=>Unit) = {
f("")
}
f10(f9)
println(f10((x:String)=>{println("wusong")}))
}
|
高阶函数的内容现在初步理解，能够做到看到理解什么意思，也能自己编写一部分。
待之后使用更加熟练时会分享经验
