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

2.5 函数至简原则

  1. return 可以省略,Scala 会使用函数体的最后一行代码作为返回值
scala 复制代码
def f1(s: String): String = {
  s + " jinlian"
}
  1. 如果函数体只有一行代码,可以省略花括号
scala 复制代码
def f2(s:String):String = s + " jinlian"
  1. 返回值类型如果能够推断出来,那么可以省略(:和返回值类型一起省略)
scala 复制代码
def f3( s : String ) = s + " jinlian"
  1. 如果有 return,则不能省略返回值类型,必须指定
scala 复制代码
def f4() :String = {
  return "ximenqing4"
}
  1. 如果函数明确声明 unit,那么即使函数体中使用 return 关键字也不起作用
scala 复制代码
def f5(): Unit = {
  return "dalang5"
}
  1. Scala 如果期望是无返回值类型,可以省略等号
scala 复制代码
def f6() {
  "dalang6"
}
  1. 如果函数无参,但是声明了参数列表,那么调用时,小括号,可加可不加
scala 复制代码
def f7() = "dalang7"
println(f7())
println(f7)
  1. 如果函数没有参数列表,那么小括号可以省略,调用时小括号必须省略
scala 复制代码
def f8 = "dalang"
//println(f8())
println(f8)
  1. 如果不关心名称,只关心逻辑处理,那么函数名(def)可以省略
scala 复制代码
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
scala 复制代码
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
scala 复制代码
object TestFunctionHigh {
  def main(args: Array[String]): Unit = {
    //在被调用函数 foo 后面加上 _,相当于把函数 foo 当成一个整体, 传递给变量 f1
    val f1 = foo _
    f1()
    println("-----------------------")
  }
  def foo(): Int = {
    println("foo...")
    1
  }
}
  1. 如果明确变量类型,那么不使用下划线也可以将函数作为整体传递给 变量
scala 复制代码
object TestFunctionHigh {
  def main(args: Array[String]): Unit = {
    //如果明确变量类型,那么不使用下划线也可以将函数作为整体传递给 变量
    var f2: () => Int = foo
    f2()
    println("-----------------------")
  }
  def foo(): Int = {
    println("foo...")
    1
  }
}

3.1.2 函数作为参数进行传递

scala 复制代码
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 函数作为函数返回值返回

scala 复制代码
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. 传递的函数有一个参数
scala 复制代码
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. 传递的函数有两个参数
scala 复制代码
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. 闭包
scala 复制代码
 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. 函数柯里化
scala 复制代码
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 中的递归必须声明函数返回值类型
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 值调用

把计算后的值传递过去

scala 复制代码
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 名调用

把代码传递过去

scala 复制代码
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 案例

scala 复制代码
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)
}
scala 复制代码
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 时,函数的执行将被推迟,直到我们首次对此取值,该函 数才会执行。这种函数我们称之为惰性函数。

scala 复制代码
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
}
相关推荐
远望清一色8 分钟前
基于MATLAB边缘检测博文
开发语言·算法·matlab
何曾参静谧16 分钟前
「Py」Python基础篇 之 Python都可以做哪些自动化?
开发语言·python·自动化
Prejudices20 分钟前
C++如何调用Python脚本
开发语言·c++·python
我狠狠地刷刷刷刷刷33 分钟前
中文分词模拟器
开发语言·python·算法
wyh要好好学习37 分钟前
C# WPF 记录DataGrid的表头顺序,下次打开界面时应用到表格中
开发语言·c#·wpf
AitTech37 分钟前
C#实现:电脑系统信息的全面获取与监控
开发语言·c#
qing_04060339 分钟前
C++——多态
开发语言·c++·多态
孙同学_40 分钟前
【C++】—掌握STL vector 类:“Vector简介:动态数组的高效应用”
开发语言·c++
froginwe1141 分钟前
XML 编辑器:功能、选择与使用技巧
开发语言
Jam-Young1 小时前
Python的装饰器
开发语言·python