做网站前需要做什么准备,wordpress图片云储存,wordpress文章调用,怎么做好推广文章目录第 5 章 函数式编程5.1 函数基础5.1.1 函数基本语法5.1.2 函数和方法的区别5.1.3 函数定义5.1.4 函数参数5.1.5 函数至简原则#xff08;重点#xff09;5.2 函数高级5.2.1 高阶函数5.2.2 匿名函数5.2.3 高阶函数案例5.2.4 函数柯里化闭包5.2.5 递归5.2.6 控制抽…
文章目录第 5 章 函数式编程5.1 函数基础5.1.1 函数基本语法5.1.2 函数和方法的区别5.1.3 函数定义5.1.4 函数参数5.1.5 函数至简原则重点5.2 函数高级5.2.1 高阶函数5.2.2 匿名函数5.2.3 高阶函数案例5.2.4 函数柯里化闭包5.2.5 递归5.2.6 控制抽象5.2.7 惰性加载第 5 章 函数式编程
1面向对象编程
解决问题分解对象行为属性然后通过对象的关系以及行为的调用来解决问题。对象用户行为登录、连接 JDBC、读取数据库属性用户名、密码Scala 语言是一个完全面向对象编程语言。万物皆对象对象的本质对数据和行为的一个封装
2函数式编程
解决问题时将问题分解成一个一个的步骤将每个步骤进行封装函数通过调用 这些封装好的步骤解决问题。例如请求-用户名、密码-连接 JDBC-读取数据库Scala 语言是一个完全函数式编程语言。万物皆函数。函数的本质函数可以当做一个值进行传递
3在 Scala 中函数式编程和面向对象编程完美融合在一起了。
5.1 函数基础
5.1.1 函数基本语法
1基本语法 2案例实操 需求定义一个函数实现将传入的名称打印出来。 object TestFunction {
def main(args: Array[String]): Unit {// 1函数定义def f(arg: String): Unit {println(arg)}// 2函数调用// 函数名参数f(hello world)}
}5.1.2 函数和方法的区别
1核心概念
1为完成某一功能的程序语句的集合称为函数。2类中的函数称之方法。
2案例实操
1Scala 语言可以在任何的语法结构中声明任何的语法2函数没有重载和重写的概念方法可以进行重载和重写3Scala 中函数可以嵌套定义
object TestFunction {// (2)方法可以进行重载和重写程序可以执行def main(): Unit {}def main(args: Array[String]): Unit {// 1Scala 语言可以在任何的语法结构中声明任何的语法import java.util.Datenew Date()// (2)函数没有重载和重写的概念程序报错def test(): Unit {println(无参无返回值)}test()def test(name:String):Unit{println()}//3Scala 中函数可以嵌套定义def test2(): Unit {def test3(name:String):Unit{println(函数可以嵌套定义)}}}
}5.1.3 函数定义
1函数定义
1函数 1无参无返回值2函数 2无参有返回值3函数 3有参无返回值4函数 4有参有返回值5函数 5多参无返回值6函数 6多参有返回值
2案例实操
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)}
}5.1.4 函数参数
1案例实操
1可变参数2如果参数列表中存在多个参数那么可变参数一般放置在最后3参数默认值一般将有默认值的参数放置在参数列表的后面4带名参数
object TestFunction {def main(args: Array[String]): Unit {// 1可变参数def test( s : String* ): Unit {println(s)}// 有输入参数输出 Arraytest(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(nameximenqing)}
}5.1.5 函数至简原则重点
函数至简原则能省则省 1至简原则细节
1return 可以省略Scala 会使用函数体的最后一行代码作为返回值2如果函数体只有一行代码可以省略花括号3返回值类型如果能够推断出来那么可以省略:和返回值类型一起省略4如果有 return则不能省略返回值类型必须指定5如果函数明确声明 unit那么即使函数体中使用 return 关键字也不起作用6Scala 如果期望是无返回值类型可以省略等号7如果函数无参但是声明了参数列表那么调用时小括号可加可不加8如果函数没有参数列表那么小括号可以省略调用时小括号必须省略9如果不关心名称只关心逻辑处理那么函数名def可以省略
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 jinlianprintln(f3(Hello3))//4如果有 return则不能省略返回值类型必须指定。def f4() :String {return ximenqing4}println(f4())//5如果函数明确声明 unit那么即使函数体中使用 return 关键字也
不起作用def f5(): Unit {return dalang5}println(f5())//6Scala 如果期望是无返回值类型,可以省略等号// 将无返回值的函数称之为过程def f6() {dalang6}println(f6())//7如果函数无参但是声明了参数列表那么调用时小括号可加可
不加def f7() dalang7println(f7())println(f7)//8如果函数没有参数列表那么小括号可以省略,调用时小括号必须省
略def f8 dalang//println(f8())println(f8)//9如果不关心名称只关心逻辑处理那么函数名def可以省略def f9 (x:String){println(wusong)}def f10(f:StringUnit) {f()}f10(f9)println(f10((x:String){println(wusong)}))}
}5.2 函数高级
5.2.1 高阶函数 在 Scala 中函数是一等公民。怎么体现的呢 对于一个函数我们可以定义函数、调用函数 object TestFunction {def main(args: Array[String]): Unit {// 调用函数
foo()}// 定义函数def foo():Unit {println(foo...)}
}但是其实函数还有更高阶的用法 1函数可以作为值进行传递
object TestFunction {def main(args: Array[String]): Unit {//1调用 foo 函数把返回值给变量 f//val f foo()val f fooprintln(f)//2在被调用函数 foo 后面加上 _相当于把函数 foo 当成一个整体
传递给变量 f1val f1 foo _foo()f1()
//3如果明确变量类型那么不使用下划线也可以将函数作为整体传递给
变量
var f2:()Int foo }def foo():Int {println(foo...)1}
}2函数可以作为参数进行传递 // 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 _))
//可以传递匿名函数
}3函数可以作为函数返回值返回
def main(args: Array[String]): Unit {def f1() {def f2() {
}
f2 _
}
val f f1()
// 因为 f1 函数的返回值依然为函数所以可以变量 f 可以作为函数继续调用
f()
// 上面的代码可以简化为
f1()()
}5.2.2 匿名函数
1说明
没有名字的函数就是匿名函数。(x:Int){函数体}x表示输入参数类型Int表示输入参数类型函数体表示具体代码逻辑
2案例实操
需求 1传递的函数有一个参数
传递匿名函数至简原则
1参数的类型可以省略会根据形参进行自动的推导2类型省略之后发现只有一个参数则圆括号可以省略其他情况没有参数和参 数超过 1 的永远不能省略圆括号。3匿名函数如果只有一行则大括号也可以省略4如果参数只出现一次则参数省略且后面参数可以用_代替 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(,))// 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(,))}
}需求 2传递的函数有两个参数 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, _ _))}
}扩展练习 练习 1定义一个匿名函数并将它作为值赋给变量 fun。函数有三个参数类型分别为 IntStringChar返回值类型为 Boolean。 要求调用函数 fun(0, “”, ‘0’)得到返回值为 false其它情况均返回 true。 练习 2 定义一个函数 func它接收一个 Int 类型的参数返回一个函数记作 f1。 它返回的函数 f1接收一个 String 类型的参数同样返回一个函数记作 f2。函数 f2 接 收一个 Char 类型的参数返回一个 Boolean 的值。 要求调用函数 func(0) (“”) (‘0’)得到返回值为 false其它情况均返回 true。 5.2.3 高阶函数案例 需求模拟 Map 映射、Filter 过滤、Reduce 聚合 object TestFunction {def main(args: Array[String]): Unit {// 1map 映射def map(arr: Array[Int], op: Int Int) {for (elem - arr) yield op(elem)}val arr map(Array(1, 2, 3, 4), (x: Int) {x * x})println(arr.mkString(,))// 2filter 过滤。有参数且参数再后面只使用一次则参数省略且
后面参数用_表示def filter(arr:Array[Int],op:Int Boolean) {var arr1:ArrayBuffer[Int] ArrayBuffer[Int]()for(elem - arr if op(elem)){arr1.append(elem)}arr1.toArray}var arr1 filter(Array(1, 2, 3, 4), _ % 2 1)println(arr1.mkString(,))// 3reduce 聚合。有多个参数且每个参数再后面只使用一次则参
数省略且后面参数用_表示第 n 个_代表第 n 个参数def reduce(arr: Array[Int], op: (Int, Int) Int) {var init: Int arr(0)for (elem - 1 until arr.length) {init op(init, elem)}init}//val arr2 reduce(Array(1, 2, 3, 4), (x, y) x * y)val arr2 reduce(Array(1, 2, 3, 4), _ * _)println(arr2)}
}5.2.4 函数柯里化闭包
闭包函数式编程的标配 1说明
闭包如果一个函数访问到了它的外部局部变量的值那么这个函数和他所处的 环境称为闭包函数柯里化把一个参数列表的多个参数变成多个参数列表。
2案例实操
1闭包
object TestFunction {def main(args: Array[String]): Unit {def f1(){
var a:Int 10def f2(b:Int){a b}f2 _}// 在调用时f1 函数执行完毕后局部变量 a 应该随着栈空间释放掉val f f1()// 但是在此处变量 a 其实并没有释放而是包含在了 f2 函数的内部形
成了闭合的效果println(f(3))println(f1()(3))// 函数柯里化其实就是将复杂的参数逻辑变得简单化,函数柯里化一定存
在闭包def f3()(b:Int){a b}println(f3()(3))}
}5.2.5 递归
1说明 一个函数/方法在函数/方法体内又调用了本身我们称之为递归调用 2案例实操
object TestFunction {def main(args: Array[String]): Unit {// 阶乘// 递归算法// 1) 方法调用自身// 2) 方法必须要有跳出的逻辑// 3) 方法调用自身时传递的参数应该有规律// 4) scala 中的递归必须声明函数返回值类型println(test(5))}def test(i : Int) : Int {if (i 1) {1} else {i * test(I - 1)}}
}5.2.6 控制抽象
1值调用把计算后的值传递过去
object TestControl {def main(args: Array[String]): Unit {def f (){println(f...)10}foo(f())}def foo(a: Int):Unit {println(a)println(a)}
}2名调用把代码传递过去
object TestControl {def main(args: Array[String]): Unit {def f (){println(f...)10}foo(f())}
//def foo(a: Int):Unit {def foo(a: Int):Unit {//注意这里变量 a 没有小括号了println(a)println(a)}
}
输出结果
f...
10
f...
10注意Java 只有值调用Scala 既有值调用又有名调用。 3案例实操
object TestFunction {def main(args: Array[String]): Unit {// 1传递代码块foo({println(aaa)})// 2小括号可以省略foo{println(aaa)}}def foo(a: Unit):Unit {println(a)println(a)}
}自定义一个 While 循环 object TestFunction {def main(args: Array[String]): Unit {var i:Int 1myWhile(i 10){println(i)i 1}}def myWhile(condition: Boolean)(op: Unit):Unit{if (condition){opmyWhile(condition)(op)}}
}5.2.7 惰性加载
1说明 当函数返回值被声明为 lazy 时函数的执行将被推迟直到我们首次对此取值该函 数才会执行。这种函数我们称之为惰性函数。 2案例实操
def main(args: Array[String]): Unit {lazy val res sum(10, 30)println(----------------)println(res res)
}
def sum(n1: Int, n2: Int): Int {println(sum 被执行。。。)return n1 n2
}
