本文介绍了Scala编程中的多范式特性，包括面向对象和函数式的结合。详细阐述了函数基础，如函数定义、函数与方法的区别、参数处理以及至简原则。此外，还深入探讨了函数的高级特性，如高阶函数、匿名函数、函数柯里化和闭包，以及递归、抽象控制和惰性函数的概念和应用实例。
一、多范式编程
- 面向对象编程：解决问题时，分解对象，行为，属性，然后通过对象的关系以及行为的调用来解决问题。
- Scala语言是一个完全面向对象编程的语言。万物皆对象
- 对象的本质：对数据和行为的一个封装
- 函数式编程：解决问题时，将问题分解成一个一个的步骤，将每个步骤进行封装（函数），通过调用这些封装好的步骤，解决问题
- Scala语言是一个完全函数式编程语言。万物皆函数。
- 函数的本质：函数可以当做一个值进行传递
- 在Scala中函数式编程和面向对象编程完美融合在一起了。
二、函数基础
2.1 函数基本语法
2.1.1 基本语法
2.1.2 案例
- 定义一个函数，实现将传入的名称打印出来
object TestFunction {
def main(args: Array[String]): Unit = {
// （1）函数定义
def f(arg: String): Unit = {
println(arg)
}
// （2）函数调用
// 函数名（参数）
f("hello world")
}
}
2.2 函数和方法的区别
2.2.1 核心概念
- 为完成某一功能的程序语句的集合，称为函数。
- 类中的函数称之方法。
2.2.2 案例实操
- Scala语言可以在任何的语法结构中声明任何的语法
- 函数没有重载和重写的概念；方法可以进行重载和重写
- Scala中函数可以嵌套定义
object TestFunction {
// (2)方法可以进行重载和重写，程序可以执行
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("函数可以嵌套定义")
}
}
}
}
2.3 函数的定义
package com.atguigu.chapter05
object TestFunctionDeclare {
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)
}
}
2.4 函数参数
object TestFunction {
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(name : String, sex : String = "男"): Unit = {
println(s"$name, $sex")
}
// Scala函数中参数传递是，从左到右
//test4("wusong")
//（4）带名参数
test4(name="ximenqing")
}
}
2.5 函数至简原则
-
函数至简原则：能省则省
2.5.1 至简原则细节
- return可以省略，Scala会使用函数体的最后一行代码作为返回值
- 如果函数体只有一行代码可以省略大括号
- 返回值类型如果可以推断出来，那么可以省略（:和返回值类型一起省略）
- 如果有return，则不能省略返回值类型，必须指定
- 如果函数明确声明unit，那么即使函数体中使用return关键字也不起作用
- Scala如果期望是无返回值，可以省略等号
- 如果函数无参，但是声明了参数列表，那么调用时，小括号可加可不加
- 如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略
- 如果不关心名称，只关心处理逻辑，那么函数名(def)可以省略
2.5.2 案例
object TestFunction {
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")}))
}
}
三、函数高级
3.1 高阶函数
- 函数作为值传递
object TestFunction {
def main(args: Array[String]): Unit = {
//（1）调用foo函数，把返回值给变量f
//val f = foo()
val f = foo
println(f)
//（2）在被调用函数foo后面加上 _，相当于把函数foo当成一个整体，传递给变量f1
val f1 = foo _
foo()
f1()
//（3）如果明确变量类型，那么不使用下划线也可以将函数作为整体传递给变量
var f2:()=>Int = foo
}
def foo():Int = {
println("foo...")
1
}
}
- 函数可以作为参数进行传递
def main(args: Array[String]): Unit = {
// （1）定义一个函数，函数参数还是一个函数签名；f表示函数名称;(Int,Int)表示输入两个Int参数；Int表示函数返回值
def f1(f: (Int, Int) => Int): Int = {
f(2, 4)
}
// （2）定义一个函数，参数和返回值类型和f1的输入参数一致
def add(a: Int, b: Int): Int = a + b
// （3）将add函数作为参数传递给f1函数，如果能够推断出来不是调用，_可以省略
println(f1(add))
println(f1(add _))
//可以传递匿名函数
}
- 函数可以作为函数返回值返回
def main(args: Array[String]): Unit = {
def f1() = {
def f2() = {
}
f2 _
}
val f = f1()
// 因为f1函数的返回值依然为函数，所以可以变量f可以作为函数继续调用
f()
// 上面的代码可以简化为
f1()()
}
3.2 匿名函数
3.2.1 说明
- 没有名字的函数就是匿名函数
- 格式
(参数:参数类型)=>{函数体}
3.2.2 传递匿名函数至简原则
- 参数类型可以省略，会根据形参进行自动推导
- 类型省略之后，发现只有一个参数，则圆括号可以省略，其他情况：没有参数和参数超过1的永远不能省略圆括号
- 匿名函数如果只有一行，则大括号也可以省略
- 如果参数只出现一次，则参数省略后面参数可以用_代替
3.2.3 案例
- 传递的函数有一个参数
def main(args: Array[String]): Unit = {
// （1）定义一个函数：参数包含数据和逻辑函数
def operation(arr: Array[Int], op: Int => Int) = {
for (elem <- arr) yield op(elem)
}
// （2）定义逻辑函数
def op(ele: Int): Int = {
ele + 1
}
// （3）标准函数调用
val arr = operation(Array(1, 2, 3, 4), op)
println(arr.mkString(",")) // mkString作用是将数组中的元素按照指定的字符隔开返回字符串
// （4）采用匿名函数
val arr1 = operation(Array(1, 2, 3, 4), (ele: Int) => {
ele + 1
})
println(arr1.mkString(","))
// （4.1）参数的类型可以省略，会根据形参进行自动的推导;
val arr2 = operation(Array(1, 2, 3, 4), (ele) => {
ele + 1
})
println(arr2.mkString(","))
// （4.2）类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过1的永远不能省略圆括号。
val arr3 = operation(Array(1, 2, 3, 4), ele => {
ele + 1
})
println(arr3.mkString(","))
// (4.3) 匿名函数如果只有一行，则大括号也可以省略
val arr4 = operation(Array(1, 2, 3, 4), ele => ele + 1)
println(arr4.mkString(","))
//（4.4）如果参数只出现一次，则参数省略且后面参数可以用_代替
val arr5 = operation(Array(1, 2, 3, 4), _ + 1)
println(arr5.mkString(","))
}
}
- 传递的函数有两个参数
object TestFunction {
def main(args: Array[String]): Unit = {
def calculator(a: Int, b: Int, op: (Int, Int) => Int): Int = {
op(a, b)
}
// （1）标准版
println(calculator(2, 3, (x: Int, y: Int) => {x + y}))
// （2）如果只有一行，则大括号也可以省略
println(calculator(2, 3, (x: Int, y: Int) => x + y))
// （3）参数的类型可以省略，会根据形参进行自动的推导;
println(calculator(2, 3, (x , y) => x + y))
// （4）如果参数只出现一次，则参数省略且后面参数可以用_代替
println(calculator(2, 3, _ + _))
}
}
3.3 函数柯里化&闭包
3.3.1 柯里化&闭包概念
- 闭包：函数式编程的标配
- 说明
- 闭包：如果一个函数，访问到了它的外部(局部)变量的值，那么这个函数和他所处的环境，称为闭包
- 函数柯里化：把一个参数列表的多个参数，变成多个参数列表
3.3.2 案例
- 闭包
package tiger.scala.chapter05
/*
* 高阶函数之函数作为返回值返回
*
* */
object Scala08_TestFun_return {
def main(args: Array[String]): Unit = {
def f1(): (Int)=>Int = {
var a:Int = 10
def f2(b:Int): Int = {
a + b
}
f2 _
}
// 执行f1函数，返回f2，将返回的f2赋值给ff变量
val ff: Int => Int = f1()
// 闭包：内层函数f2要访问外层函数f1局部变量，当外层函数f1执行结束之后，f1会释放栈内存，但是会自动的延长f1函数的局部变量的生命周期，
// 和内层函数的f2形成一个闭合的效果，我们将这种闭合的效果称之为闭包
// 闭包 = 外层函数的局部变量 + 内层函数
// 如果存在闭包，编译器会生成包含$anonfun$的字节码文件
// 调用ff函数就是调用f2
println(ff(20))
// 也可以通过如下方式调用
println(f1()(20))
//-------------------------------------------------------
//以上代码可以转为如下代码
def f3(): (Int)=>Int = {
var a:Int = 10
(b:Int) => a + b
}
println(f3()(2))
// 柯里化
// 将一个函数的一个参数列表中的多个参数，拆分为多个参数列表
// 简化闭包代码的编写
def f4()(b:Int):Int = {
var a:Int = 10
a + b
}
// f4在执行的时候会转换为以下结构
// def f4(): Int=>Int = {
// var a:Int = 10
// (b:Int) => a + b
// }
// 柯里化，是对函数嵌套的简化，但是这里只有一层函数体，如果每层函数完成的业务逻辑不一样，一个函数该如何处理
//
}
}
3.4 递归
-
一个函数/方法在函数/方法体内又调用了本身，我们称之为递归调用
package tiger.scala.chapter05
object Scala09_TesFun_jc {
def main(args: Array[String]): Unit = {
def jc(n: Int):Int = {
if (n == 1) {
return 1 // 必须要加上return，否则该函数每次返回的都是最后一行代码
}
n * jc(n - 1)
}
println(jc(5))
}
}
3.5 抽象控制
package tiger.scala.chapter05
/*
* 控制抽象
* 值调用
* 将函数计算后的值进行传递
* 名调用
* 传递的是代码块
*
* */
object Scala10_TestControlAbstract {
def main(args: Array[String]): Unit = {
// // 值调用，将函数计算后的值进行传递
// def foo(a:Int):Unit = {
// println(a)
// println(a)
// }
//
// def f: Int = {
// println("f....")
// 10
// }
//
// foo(f)
// 名调用：传递代码块
// 数据类型：Int，String，函数 参数类型=>返回值，代码块：=>返回值类型
def foo(a: => Int):Unit = {
println(a)
println(a)
}
def f(): Int = {
println("f....")
10
}
foo(f())
}
}
- 自定义while循环
package tiger.scala.chapter05
// 自定义函数，实现while循环
object Scala11_TestMyWhile {
def main(args: Array[String]): Unit = {
/*
* while(循环条件) {
* 循环体
* }
* */
// 使用柯里化，来实现mywhile(循环条件)(循环体)
// 柯里化好处1：将一个参数列表的多个参数，拆分为多个参数列表，这样参数所表示的含义，清晰、明确
// 简化闭包代码的编写
def myWhile(conditon: =>Boolean)(op: => Unit):Unit = {
if (conditon) {
op
myWhile(conditon)(op)
}
}
var n = 10
myWhile(n >= 1)({
println("mywhile-->" + n)
n -= 1
})
// 使用闭包实现mywhile循环
def myWhile2(condition: =>Boolean): (=>Unit)=>Unit = {
// 内层函数的参数表示循环体
def ff(op: =>Unit): Unit = {
if (condition) {
op
myWhile2(condition)(op)
}
}
ff _
}
var a = 10
myWhile2(a >= 1)({
println("mywhile-->" + a)
a -= 1
})
}
}
3.6 惰性函数
3.6.1 说明
- 当函数返回值被声明为lazy时，函数的执行将被推迟，直到我们首次对此取值，该函数才会执行。这种函数我们称之为惰性函数。
3.6.2 案例
package tiger.scala.chapter05
object Scala13_TestLazy {
def main(args: Array[String]): Unit = {
// 惰性加载，函数的执行会被后延，什么时候用到了结果什么时候执行函数
lazy val res:Int = sum(2, 3)
println("-------------------")
println(res)
}
def sum(a:Int, b:Int): Int = {
println("sum被执行了")
a + b
}
}
扫一扫
1188
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
