【Scala】——函数式编程

1 面向对象编程和函数式编程

1.1 面向对象编程

  1. 解决问题，分解对象，行为，属性，然后通过对象的关系以及行为的调用来解决问题。
    • 对象：用户
    • 行为：登录、连接 JDBC、读取数据库
    • 属性：用户名、密码
  2. Scala 语言是一个完全面向对象编程语言。万物皆对象
  3. 对象的本质：对数据和行为的一个封装

1.2 函数式编程

  1. 解决问题时，将问题分解成一个一个的步骤，将每个步骤进行封装（函数），通过调用 这些封装好的步骤，解决问题。 例如：请求->用户名、密码->连接 JDBC->读取数据库
  2. Scala 语言是一个完全函数式编程语言。万物皆函数。
  3. 函数的本质：函数可以当做一个值进行传递

2 函数基础

2.1 基本语法

在这里插入图片描述

2.2 函数和方法的区别

  1. 为完成某一功能的程序语句的集合，称为函数。
  2. 类中的函数称之方法。
  3. Scala 语言可以在任何的语法结构中声明任何的语法
  4. 函数没有重载和重写的概念；方法可以进行重载和重写
  5. Scala 中函数可以嵌套定义
package com.scala
package chapter05object TestFunction {//(2)方法可以进行重载和重写，程序可以执行def test(): Unit = {}def test(name: String): Unit = {}def main(args: Array[String]): Unit = {// （1）Scala 语言可以在任何的语法结构中声明任何的语法import java.util.Datenew Date()def test(): Unit = {println("无参，无返回值")}test()//(3)函数没有重载和重写的概念，程序报错// def test(name: String): Unit = {////}//（4）Scala 中函数可以嵌套定义def test2(): Unit = {def test3(name: String): Unit = {println(name + "函数可以嵌套定义")}test3("zhangsan")}test2()}}

2.3 函数定义

  1. 函数 1：无参，无返回值
  2. 函数 2：无参，有返回值
  3. 函数 3：有参，无返回值
  4. 函数 4：有参，有返回值
  5. 函数 5：多参，无返回值
  6. 函数 6：多参，有返回值
package com.scala
package chapter05object 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)// 函数 6：多参，有返回值def test6(name: String, age: Int): String = {println(s"$name, $age")return name+age}test6("aaaa", 40)}}

2.4 函数参数

  1. 可变参数
def test(s:String*):Unit={println(s)
}
// 有输入参数：输出 Array
test("qwe","asd")
// 无输入参数：输出 List()
test()
  1. 如果参数列表中存在多个参数，那么可变参数一般放置在最后
def test2(name: String, s: String*): Unit = {println(name + "," + s)
}
test2("jinlian", "dalang")
  1. 参数默认值，一般将有默认值的参数放置在参数列表的后面，如果参数传递了值，那么会覆盖默认值，如果参数有默认值，在调用的时候，可以省略这个参数
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")
}
  1. 带名参数， Scala 函数中参数传递是，从左到右，如果参数的左边有可变参数或者有默认值的参数，可将参数指定给某个参数
def test4(sex: String = "男", name: String): Unit = {println(s"$name, $sex")
}   
test4(name = "ximenqing")

2.5 函数至简原则

  1. return 可以省略，Scala 会使用函数体的最后一行代码作为返回值
def f1(s: String): String = {s + " jinlian"
}
  1. 如果函数体只有一行代码，可以省略花括号
def f2(s:String):String = s + " jinlian"
  1. 返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）
def f3( s : String ) = s + " jinlian"
  1. 如果有 return，则不能省略返回值类型，必须指定
def f4() :String = {return "ximenqing4"
}
  1. 如果函数明确声明 unit，那么即使函数体中使用 return 关键字也不起作用
def f5(): Unit = {return "dalang5"
}
  1. Scala 如果期望是无返回值类型，可以省略等号
def f6() {"dalang6"
}
  1. 如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加
def f7() = "dalang7"
println(f7())
println(f7)
  1. 如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略
def f8 = "dalang"
//println(f8())
println(f8)
  1. 如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略
def f9 = (x:String)=>{println("wusong")}
def f10(f:String=>Unit) = {f("")
}
f10(f9)
println(f10((x:String)=>{println("wusong")}))

3 函数高级

3.1 高阶函数

对于一个函数我们可以：定义函数、调用函数，但是其实函数还有更高阶的用法

3.1.1 函数作为值进行传递

  1. 调用 foo 函数，把返回值给变量 f
object TestFunctionHigh {def main(args: Array[String]): Unit = {//调用 foo 函数，把返回值给变量 f//val f = foo()val f = fooprintln(f)}def foo(): Int = {println("foo...")1}
}
  1. 在被调用函数 foo 后面加上 _，相当于把函数 foo 当成一个整体， 传递给变量 f1
object TestFunctionHigh {def main(args: Array[String]): Unit = {//在被调用函数 foo 后面加上 _，相当于把函数 foo 当成一个整体， 传递给变量 f1val f1 = foo _f1()println("-----------------------")}def foo(): Int = {println("foo...")1}
}
  1. 如果明确变量类型，那么不使用下划线也可以将函数作为整体传递给 变量
object TestFunctionHigh {def main(args: Array[String]): Unit = {//如果明确变量类型，那么不使用下划线也可以将函数作为整体传递给 变量var f2: () => Int = foof2()println("-----------------------")}def foo(): Int = {println("foo...")1}
}

3.1.2 函数作为参数进行传递

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 _))//可以传递匿名函数
}

3.1.3 函数作为函数返回值返回

def main(args: Array[String]): Unit = {def f1() = {def f2() = {println("f2----")}f2 _}val f = f1()// 因为 f1 函数的返回值依然为函数，所以可以变量 f 可以作为函数继续调用f()// 上面的代码可以简化为f1()()
}

3.2 匿名函数

3.2.1 概述

没有名字的函数就是匿名函数
(x:Int)=>{函数体}
x：表示输入参数类型；Int：表示输入参数类型；函数体：表示具体代码逻辑

3.2.2 传递匿名函数至简原则：

  1. 参数的类型可以省略，会根据形参进行自动的推导
  2. 类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过 1 的永远不能省略圆括号。
  3. 匿名函数如果只有一行，则大括号也可以省略
  4. 如果参数只出现一次，则参数省略且后面参数可以用_代替

3.2.2 案例实操

  1. 传递的函数有一个参数
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(","))
}
  1. 传递的函数有两个参数
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 说明

  1. 闭包：如果一个函数，访问到了它的外部（局部）变量的值，那么这个函数和他所处的 环境，称为闭包
  2. 函数柯里化：把一个参数列表的多个参数，变成多个参数列表。函数柯里化，其实就是将复杂的参数逻辑变得简单化,函数柯里化一定存 在闭包

3.3.2 案例

  1. 闭包
 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))}
  1. 函数柯里化
def main(args: Array[String]): Unit = {// 函数柯里化，其实就是将复杂的参数逻辑变得简单化,函数柯里化一定存 在闭包def f3()(b: Int) = {var a: Int = 10println("b="+b)a + b}println(f3()(3))
}

3.4 递归

一个函数/方法在函数/方法体内又调用了本身，我们称之为递归调用

  1. 方法调用自身
  2. 方法必须要有跳出的逻辑
  3. 方法调用自身时，传递的参数应该有规律
  4. scala 中的递归必须声明函数返回值类型
def main(args: Array[String]): Unit = {// 阶乘// 递归算法println(test(5))
}def test(i: Int): Int = {if (i == 1) {1} else {i * test(i - 1)}
}

3.5 控制抽象

3.5.1 值调用

把计算后的值传递过去

def main(args: Array[String]): Unit = {def f = () => {println("f...")10}foo(f())
}def foo(a: Int): Unit = {println(a)println(a)
}

3.5.2 名调用

把代码传递过去

def main(args: Array[String]): Unit = {def f = () => {println("f...")10}foo(f())
}def foo(a: => Int): Unit = { //注意这里变量 a 没有小括号了println(a)println(a)
}

3.5.3 案例

def main(args: Array[String]): Unit = {// （1）传递代码块foo({println("aaa")10})// （2）小括号可以省略foo {println("aaa")10}}def foo(a: => Int): Unit = {println(a)println(a)
}

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)}
}

3.6 惰性加载

  当函数返回值被声明为 lazy 时，函数的执行将被推迟，直到我们首次对此取值，该函 数才会执行。这种函数我们称之为惰性函数。

def main(args: Array[String]): Unit = {lazy val res = sum(10, 30)println("----------------")println("res=" + res)println("----------------------------------------------------------------")val res1 = sum(10, 30)println("----------------")println("res1=" + res1)
}def sum(n1: Int, n2: Int): Int = {println("sum 被执行。。。")n1 + n2
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/333766.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Linux学习记录——삽심칠 传输层TCP协议（2）

Linux学习记录——삽심칠 传输层TCP协议（2）

文章目录 1、滑动窗口2、拥塞控制3、延迟应答4、捎带应答5、总结TCP可靠性和性能提高6、面向字节流7、粘包问题8、异常情况9、全连接、半连接 上一篇是传输层TCP协议&#xff08;1&#xff09;。本篇默认读者已经清楚TCP报头各个部分、可靠性和握手挥手的含义。 有时候会把客户…
阅读更多...
AI大语言模型会带来了新一波人工智能浪潮？

AI大语言模型会带来了新一波人工智能浪潮？

以ChatGPT、LLaMA、Gemini、DALLE、Midjourney、Stable Diffusion、星火大模型、文心一言、千问为代表AI大语言模型带来了新一波人工智能浪潮&#xff0c;可以面向科研选题、思维导图、数据清洗、统计分析、高级编程、代码调试、算法学习、论文检索、写作、翻译、润色、文献辅助…
阅读更多...
eclipse正则表达式替换 Find/Replace

eclipse正则表达式替换 Find/Replace

Find/Replace 对话框中使用正则表达式 CTRLF 打开 Find/Replace 对话框勾选 Regular expressions ​ 匹配注释 下图中的Find&#xff1a;/.*/ ​ 匹配换行符 换行符&#xff1a;\R 下图中的Find表达式&#xff1a;\R.*Excel.* ​ 新增空行 /** 替换为 \R\t/** ​ 选…
阅读更多...
FreeRTOS学习总结（二）FreeRTOS任务创建和删除API函数

FreeRTOS学习总结（二）FreeRTOS任务创建和删除API函数

实现动态创建任务流程 任务控制块结构体成员介绍 typedef struct tskTaskControlBlock {volatile StackType_t * pxTopOfStack; /* 任务栈栈顶&#xff0c;必须为TCB第一个成员 */ListItem_t xStateListItem; /* 任务状态列表项 */ Li…
阅读更多...
【深度学习每日小知识】Data Augmentation 数据增强

【深度学习每日小知识】Data Augmentation 数据增强

数据增强是通过对原始数据进行各种转换和修改来人工生成附加数据的过程&#xff0c;旨在增加机器学习模型中训练数据的大小和多样性。这对于计算机视觉领域尤为重要&#xff0c;因为图像经常被用作输入数据。 计算机视觉中的数据增强 数据增强的主要目标是解决过拟合问题&…
阅读更多...
abp vnext 下载指定版本的项目

abp vnext 下载指定版本的项目

开发环境 Win11 vs2022 abp vnext 下载地址&#xff1a;Get Started | ABP.IO 下载abp框架之前&#xff0c;需要先安装CLI&#xff0c;打开命令提示符&#xff0c;执行以下命令即可&#xff0c;这个也可以指定版本下载&#xff0c;这里就不做介绍了&#xff0c;以及删除命令…
阅读更多...
110.线程（创建、终止）

110.线程（创建、终止）

一、线程概述 ◼ 与进程&#xff08;process&#xff09;类似&#xff0c;线程&#xff08;thread&#xff09;是允许应用程序并发执行多个任务的一种机 制。一个进程可以包含多个线程。同一个程序中的所有线程均会独立执行相同程序&#xff0c;且共 享同一份全局内存区域&…
阅读更多...
低抖动可编程SPXO SG-8200CG, SG-8201CG -高稳定性和低抖动特性

低抖动可编程SPXO SG-8200CG, SG-8201CG -高稳定性和低抖动特性

描述 SG-8200CG和SG-8201CG (sg -8201系列)利用爱普生新的低噪声分n锁相环技术&#xff0c;与上一代爱普生可编程晶体振荡器相比&#xff0c;稳定性提高了约2x&#xff0c;相位抖动降低了<1/25。sg -8201系列可编程为1.2MHz至170MHz的任何频率&#xff0c;工作温度范围可达…
阅读更多...
C#，背包问题（Knapsack Problem）贪心算法的源代码

C#，背包问题（Knapsack Problem）贪心算法的源代码

背包问题&#xff08;KnapSack Problem&#xff09;的相关算法是常用的规划算法。 一、什么是背包问题&#xff1f; 背包的问题是&#xff0c;你有一个“袋子”&#xff0c;可以装有限数量的物品&#xff0c;鉴于你有一组物品可以从每个物品中选择&#xff0c;每个物品都有各自…
阅读更多...
Spring基于注解的AOP控制事务

Spring基于注解的AOP控制事务

首先在.xml中开启sprong对注解事务的支持 applicationContext.xml <tx:annotation-driven transaction-manager"transactionManager"/> 然后再Service中加上注解 service Service Transactional(readOnlytrue,propagation Propagation.SUPPORTS) public cl…
阅读更多...
MySQL高可用解决方案演进：从主从复制到InnoDB Cluster架构

MySQL高可用解决方案演进：从主从复制到InnoDB Cluster架构

&#x1f482; 个人网站:【 海拥】【神级代码资源网站】【办公神器】&#x1f91f; 基于Web端打造的&#xff1a;&#x1f449;轻量化工具创作平台&#x1f485; 想寻找共同学习交流的小伙伴&#xff0c;请点击【全栈技术交流群】 当谈论MySQL高可用性解决方案时&#xff0c;从…
阅读更多...
java中实现对文件高效的复制

java中实现对文件高效的复制

不多说我们直接上代码&#xff1a; 这个是使用NIO包下的FileChannel和ByteBuffer进行文件的操作的&#xff0c;会比较高效。
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023