【Scala】——函数式编程

最新推荐文章于 2024-07-16 08:55:38 发布
最新推荐文章于 2024-07-16 08:55:38 发布
阅读量1.3k 收藏 25
点赞数 27
分类专栏： scala bigdata 文章标签： scala 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42000631/article/details/135480061
版权
本文介绍了Scala中的面向对象编程和函数式编程概念，包括对象和函数的本质，以及函数的基础语法、重载与重写、嵌套定义等。此外，文章还详细讲解了函数参数、高阶函数、匿名函数、柯里化、递归、控制抽象和惰性加载等高级特性。
摘要由CSDN通过智能技术生成

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
}
那时的样子_
关注
  • 27
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《Scala 3》--函数式编程
yk_3215123的博客
07-28 221
函数式编程： 函数式编程的特点 函数式编程核心价值在于多核编程。 1） 参数私有 val，没有线程安全问题，这样就为分布式高并发提供了支持 2） 把函数做为参数 3） 把函数的返回值作为参数 定义:在js中方法和函数比较模糊。scala中的函数和方法不同，函数在scala中是一等公民。 格...
【图文详细 】Scala——编程练习
谦卑t
12-19 3616
6、Scala 编程练习  6.1、99 乘法表  package com.mazh.scala.funny object Table99 { def main(args: Array[String]): Unit = { for (i &lt;- 1 to 9){ for (j &lt;- 1 to i){ printf("%d*%...
scala函数式编程基础
m0_59360502的博客
04-17 281
函数式编程是一种编程范式，它强调使用函数来处理数据，而不是像面向对象编程那样使用对象。这种编程范式的核心概念是函数的纯函数和高阶函数。
Scala函数式编程
libaowenBlog的博客
08-16 1179
Scala是一门既面向对象，又面向过程的语言。在Scala中，函数与类、对象地位是一样，所以说scala的面向过程其实就重在针对函数的编程 了，所以称之为函数式编程。
Scala——函数式编程、面向对象
qq_42873479的博客
03-19 720
Scala——函数式编程5 函数式编程5.1 函数基础5.2 函数高级5.2.1 匿名函数5.2.2 高阶函数5.2.3 高阶函数练习5.2.4 函数柯里化&闭包5.2.4 递归5.2.5 控制抽象5.2.6 惰性加载6 面向对象6.1 Scala包6.1.1 包的命名6.1.2 包说明（包语句）6.1.3 包对象6.1.4 包导入6.2 类和对象6.2.1 定义类6.2.2 属性6.3 封装6.4 继承和多态6.5 抽象类6.6 单例对象（伴生对象）6.7 特质（Trait）6.
Scala—— 3.函数
01-07
函数式编程是从编程方式(范式)的角度来谈的，可以这样理解：函数式编程把函数当作一等公民，充分利用函数、只是函数的多种使用方式，在Scala中，函数是一等公民，像变量一样，既可以作为函数的参数使用，也可以将...
java8stream源码-java8:Java8——函数式编程
06-04
函数式编程 介绍 该存储库包含例如 Java 8 In Action 和 Java 8 Lambdas Pragmatic Functional Programming 一书中的源代码。 同时自己也做了一些扩展使用，修复了源码中的bug。 例如 Java 8 In Action 中的源代码...
Scala—— 1.变量
01-07
Scala是一门以Java虚拟机（JVM）为运行环境并***将面向对象和函数式编程的最佳特性结合在一起的静态类型编程语言***。Scala源代码（.scala）会被编译成Java字节码（.class），然后运行在JVM上，并可以调用现有的Java...
Scala—— 9.伴生对象apply方法
01-20
总结来说，Scala中的伴生对象和`apply`方法结合，提供了一种方便的、函数式的创建对象的方式。通过在伴生对象中定义`apply`方法，我们可以使类的实例化更加灵活，同时保持代码的简洁性。这对于构建模块化的、可扩展...
Perl 语言开发（十五）：调试和测试
07-14 1168
在软件开发过程中，调试和测试是确保代码质量的关键环节。对于Perl语言的开发者来说，掌握有效的调试和测试技巧，不仅能提高开发效率，还能保证代码的健壮性和可靠性。本文将详细介绍Perl中的调试和测试方法，包括常用的调试工具和测试框架，如何编写测试用例，以及实际项目中的调试和测试技巧。
SpinalHDL之实用工具（上篇）
m0_59092412的博客
07-11 1234
本文作为SpinalHDL学习笔记第十三篇，记录使用SpinalHDL的一些实用性语法工具。然后，通过使用这些功能可以定义数字硬件，并构建强大的库和抽象。这也是 SpinalHDL 相对于其他常用 HDL 的主要优势之一，因为无需了解编译器内部原理即可扩展该语言。一个很好的例子是SpinalHDL lib，它添加了许多实用程序、工具、总线和方法。许多工具和实用程序都存在于spinal.lib 中，但有些工具和实用程序已经存在于 SpinalHDL Core 中。语法返回类型描述Int。
Linux工具应用_PERL
qq_39355579的博客
07-15 395
Perl是由Larry Wall设计的，并由他不断更新和维护的编程语言。Perl具有高级语言（如C）的强大能力和灵活性。事实上，你将看到，它的许多特性是从C语言中借用来的。Perl与脚本语言一样，Perl不需要compiler和elabrator来运行代码，你要做的只是写出程序并告诉Perl来运行而已。这意味着Perl对于小的编程问题的快速解决方案和为大型事件创建原型来测试潜在的解决方案是十分理想的。Perl提供脚本语言（如sed和awk）的所有功能，还具有它们所不具备的很多功能。
Perl 基础语法精讲：变量、操作符与控制结构
weixin_41859354的博客
07-11 723
Perl 是一种解释型的高级脚本语言，广泛用于文本处理、系统管理任务等。
SpinalHDL之实用工具（下篇）
m0_59092412的博客
07-12 1782
本文作为SpinalHDL学习笔记第十四篇，记录使用SpinalHDL的一些实用性语法工具。
Perl 语言入门学习
最新发布
Chujun123528的博客
07-16 421
Perl（Practical Extraction and Report Language）是一种功能强大的编程语言，由Larry Wall于1987年创建。它的设计初衷是为了方便文本处理，同时也具备强大的系统管理和网络编程功能。Perl的语法灵活多变，既可以编写简单的脚本，也能开发复杂的应用程序。它广泛用于文本处理、系统管理、网络编程、图形编程等领域，是一种高级的、动态的、解释型的通用编程语言。
技术周总结 2024.07.08~07.14(算法，Python,Java,Scala,PHP)
xinkuaile的专栏
07-13 937
力扣算法题，java, python等实现
SpinalHDL之VHDL 和 Verilog 生成
m0_59092412的博客
07-14 725
本文作为SpinalHDL学习笔记第十六篇，记录使用SpinalHDL代码生成Verilog/VHDL代码的方法。SpinalHDL学习笔记总纲链接如下：1.从 SpinalHDL 组件生成 VHDL 和 Verilog2.生成的 VHDL 和 Verilog3.VHDL 和 Verilog 属性要 从 SpinalHDL 组 件 生 成 VHDL， 只 需 在 Scala main 函 数 中 调 用 SpinalVhdl(newYourComponent) 即可。生成 Verilog 完全相同，但用 S
Scala学习笔记16: 注解
Taerge0110的博客
07-12 819
Scala 中的注解 (Annotations) 是一种元编程工具, 用于向编译器、运行时或其他工具提供元数据 ; 注解可以应用于各种程序结构, 包括类、对象、方法、字段、参数等 ; 下面是对Scala注解的详细介绍, 包括常见的注解、如何定义自定义注解, 以及使用注解的一些示例 ;
scala函数式编程pdf
06-24
《Scala函数式编程》是一本非常实用的Scala编程书籍，旨在教读者如何使用Scala编程语言实现函数式编程。该书通过具体的实例和案例来阐述Scala函数式编程的核心概念和技术，包括函数式编程基础、函数的高阶抽象、类型...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值