【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 chapter05

object TestFunction {

  //(2)方法可以进行重载和重写，程序可以执行
  def test(): Unit = {

  }
  def test(name: String): Unit = {

  }

  def main(args: Array[String]): Unit = {

    // （1）Scala 语言可以在任何的语法结构中声明任何的语法
    import java.util.Date
    new 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 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)

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

      def 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 = 10
    println("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 = 1
  myWhile(i <= 10){
    println(i)
    i +=1
  }
}
def myWhile(condition: =>Boolean)(op: =>Unit):Unit={
  if (condition){
    op
    myWhile(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
}

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

springboot2.7集成sharding-jdbc4.1.1实现业务分表

springboot2.7集成sharding-jdbc4.1.1实现业务分表

1、引入maven <dependency><groupId>org.apache.shardingsphere</groupId><artifactId>sharding-jdbc-spring-boot-starter</artifactId><version>4.1.1</version></dependency> 2、基本代码示例 基本逻辑&#xff1a;利用数…
阅读更多...
windows10+ubuntu20.04双系统中，ubuntu系统显示home空间不足的扩容方法

windows10+ubuntu20.04双系统中，ubuntu系统显示home空间不足的扩容方法

实际上网上有两种扩容方法&#xff0c;除了本文的方法外&#xff0c;另一种是在使用启动U盘打开试用ubuntu&#xff0c;应该涉及到nvidia显卡驱动问题故未采用。另一种即本文。 最开始安装双系统时内存分配没有分配好&#xff0c;给ubuntu系统分配的空间较小,导致了后来的的问…
阅读更多...
vivado xsim 终端 模拟

vivado xsim 终端 模拟

只模拟的话直接终端运行会快很多 计数器举例 mkdir srccounter.v module counter(input wire clk,input wire rst_n,output reg[31:0] cnt ); always (posedge clk or negedge rst_n)if(!rst_n)cnt < 31h0;elsecnt < cnt1;endmodule tb.v module tb; wire[31:0] out…
阅读更多...
Python - Bert-VITS2 自定义训练语音

Python - Bert-VITS2 自定义训练语音

目录 一.引言 二.前期准备 1.Conda 环境搭建 2.Bert 模型下载 3.预训练模型下载 三.数据准备 1.音频文件批量处理 2.训练文件地址生成 3.模型训练配置生成 4.训练文件重采样 5.Tensor pt 文件生成 四.模型训练 1.预训练模型 2.模型训练 3.模型收菜 五.总结 一…
阅读更多...
基于模块自定义扩展字段的后端逻辑实现（二）

基于模块自定义扩展字段的后端逻辑实现（二）

目录 一&#xff1a;创建表 二&#xff1a;代码逻辑 上一节我们详细讲解了自定义扩展字段的逻辑实现和表的设计&#xff0c;这一节我们以一个具体例子演示下&#xff0c;如何实现一个订单模块的自定义扩展数据。 一&#xff1a;创建表 订单主表: CREATE TABLE t_order ( …
阅读更多...
流量主答题小程序源码系统：自定义题库或一键导入，采用PHP+MySQL 带完整的安装部署教程

流量主答题小程序源码系统：自定义题库或一键导入，采用PHP+MySQL 带完整的安装部署教程

随着互联网的发展&#xff0c;答题类小程序因其互动性强、用户粘性高等特点&#xff0c;受到了广泛的欢迎。小编来给大家分享一款流量主答题小程序源码系统。该系统采用PHPMySQL技术&#xff0c;功能强大且易于扩展&#xff0c;为开发者提供了一个完整的答题平台解决方案。 以…
阅读更多...
【APP抓包】IOS应用抓包防护绕过实战教程

【APP抓包】IOS应用抓包防护绕过实战教程

文章目录 1. 写在前面2. 测试机越狱2.1. 爱思助手2.2. checkra1n 3. 代理抓包3.1. 安装CA证书 4. 客户端证书绑定绕过4.1. SSLKillSwitch4.2. Objection 5. 双向证书绑定绕过5.1. 绕过服务端 6. 越狱检测绕过6.1. Liberty Lite绕过检测6.2. Hestia绕过检测6.3. HideJB绕过检测6…
阅读更多...
智能化配网故障定位技术：未来发展趋势与应用前景

智能化配网故障定位技术：未来发展趋势与应用前景

在当今这个科技高速发展的时代&#xff0c;智能化技术已经渗透到了我们生活的方方面面。作为电力行业的重要组成部分&#xff0c;配电网的自动化和智能化水平也在不断提高。本文将重点介绍一种基于成熟的行波测距技术的智能化配网故障定位技术——配网行波型故障预警与定位系统…
阅读更多...
Vue3-watch的用法

Vue3-watch的用法

watch简介 作用:监视数据的变化 (和 Vue2 中的 watch 作用一致) 特点: Vue3 中的 watch 只能监视以下四种数据 1.ref 定义的数据(又可以分 基本 和 对象 ) 2.reactive 定义的数据 3.函数返回一个值。(getter 函数) 4.一个包含上述内容的数组 我们在 Vue3 中使用 watch …
阅读更多...
Zookeeper系列（一）集群搭建（非容器）

Zookeeper系列（一）集群搭建（非容器）

系列文章 Zookeeper系列&#xff08;一&#xff09;集群搭建&#xff08;非容器&#xff09; 目录 前言 下载 搭建 Data目录 Conf目录 集群复制和修改 启动 配置示例 测试 总结 前言 Zookeeper是一个开源的分布式协调服务&#xff0c;其设计目标是将那些复杂的且容易出错的分…
阅读更多...
CHS_01.1.5+操作系统引导

CHS_01.1.5+操作系统引导

CHS_01.1.5操作系统引导 操作系统的引导一个新的磁盘安装操作系统后操作系统引导&#xff08;开机过程&#xff09; 操作系统的引导 我们会学习操作系统的引导 那你可能看见这个词的时候会觉得莫名其妙不明 绝地 什么是操作系统的引导呢 简单来说就是当你在开机的时候 如何让…
阅读更多...
apt和apt-get的区别

apt和apt-get的区别

文章目录 环境问题背景区别进度条显示可更新包的数量upgrade 对比apt-get 过时了吗使用apt还是apt-get总结参考 环境 RHEL 9.3Docker Community 24.0.7Ubuntu Docker image jammy 22.04lunar 23.04 Ubuntu 22.04 问题 apt 和 apt-get 有一些相似之处。比如&#xff0c;如果想…
阅读更多...
在VS Code中安装Copilot与安装其他扩展的方法一样，只需简单几步

在VS Code中安装Copilot与安装其他扩展的方法一样，只需简单几步

GitHub Copilot是由OpenAI和GitHub开发的人工智能工具。它的目的是通过自动完成代码来帮助开发人员使用集成开发环境&#xff08;IDE&#xff09;&#xff0c;如Visual Studio Code。它目前仅作为技术预览版提供&#xff0c;因此只有在候补名单上被认可的用户才能访问它。对于用…
阅读更多...
Spark避坑系列一（基础知识）

Spark避坑系列一（基础知识）

大家想了解更多大数据相关内容请移驾我的课堂： 大数据相关课程 剖析及实践企业级大数据 数据架构规划设计 大厂架构师知识梳理：剖析及实践数据建模 剖析及实践数据资产运营平台 Spark作为大数据领域离线计算的王者，在分布式数据处理计算领域有着极高的处理效率，而Python作为…
阅读更多...
智能商品管理系统相比传统商品管理在自动化程度上有哪些优势?

智能商品管理系统相比传统商品管理在自动化程度上有哪些优势?

智能商品管理系统相比传统商品管理模式&#xff0c;在自动化程度上具有以下具体优势&#xff1a; 1、数据自动采集&#xff1a;智能商品管理系统通过传感器、物联网等技术&#xff0c;可以自动采集商品的销售数据、库存情况、市场趋势等信息&#xff0c;无需人工干预。这样可以…
阅读更多...
Qrcode生成中间带log的二维码图片

Qrcode生成中间带log的二维码图片

Qrcode生成中间带log的二维码图片 1.引入依赖 <dependency><groupId>com.swetake.util</groupId><artifactId>QRCode</artifactId><version>3.0</version></dependency>2.测试 public class QRCodeUtil {public static int …
阅读更多...
LeetCode 94. 二叉树的中序遍历

LeetCode 94. 二叉树的中序遍历

94. 二叉树的中序遍历 给定一个二叉树的根节点 root &#xff0c;返回 它的 中序 遍历 。 示例 1&#xff1a; 输入&#xff1a;root [1,null,2,3] 输出&#xff1a;[1,3,2] 示例 2&#xff1a; 输入&#xff1a;root [] 输出&#xff1a;[] 示例 3&#xff1a; 输入&…
阅读更多...
cctalk录屏去水印翻录过检测教程

cctalk录屏去水印翻录过检测教程

最近在上cctalk的网课时候&#xff0c;遇到了这种情况&#xff0c;无法打开录屏工具&#xff0c;打开了录屏软件会被播放器检测&#xff0c;无法正常播放网课视频&#xff0c;可以用这个工具&#xff0c;就可以随便录了&#xff0c;而且可以去用户名水印。 使用方法也很简单&a…
阅读更多...
springboot+java+bootstrap商场摊位商铺租赁管理系统

springboot+java+bootstrap商场摊位商铺租赁管理系统

商铺租赁管理系统分为管理员&#xff0c;房东&#xff0c;用户三种角色。 &#xff08;1&#xff09;管理员功能&#xff1a;管理员管理房东&#xff0c;管理公告&#xff0c;管理商铺出租&#xff0c;租赁合同等信息。 &#xff08;2&#xff09;房东功能&#xff1a;房东审核…
阅读更多...
参数小，性能强！开源多模态模型—TinyGPT-V

参数小，性能强！开源多模态模型—TinyGPT-V

安徽工程大学、南洋理工大学和理海大学的研究人员开源了多模态大模型——TinyGPT-V。 TinyGPT-V以微软开源的Phi-2作为基础大语言模型&#xff0c;同时使用了视觉模型EVA实现多模态能力。尽管TinyGPT-V只有28亿参数&#xff0c;但其性能可以媲美上百亿参数的模型。 此外&…
阅读更多...
最新文章

Copyright @ 2022~2023