Scala语言
点击跳转到 Scala语言超详细介绍（上）
24、高阶函数
概念
Scala 混合了面向对象和函数式的特征，我们通常将==可以作为参数传递的方法中的表达式叫做函数。==在函数式编程语言中，函数是“头等公敌”，把函数作为参数或者是返回值是函数的函数叫高阶函数。
高阶函数包含：作为值的函数、匿名函数、闭包、柯里化等等。
作为值的函数
可以向任何其他数据类型一样被传递和操作的函数，每当你想要给算法传入具体动作时，这个特性就会变得非常有用。
/**
* 作为值的函数
*/
object MyFunction {
def main(args: Array[String]): Unit = {
//定义一个数组
val arr: Array[Int] = Array(1, 2, 3, 4)
//定义一个函数并将函数复制给fun1
val fun1 = (x: Int) => {
x * 2
}
//同过map方法把调用fun1函数
val map: Array[Int] = arr.map(fun1)
map.foreach(line => {
println(line)
})
}
}
定义函数时的格式：val 变量名 = （输入参数类型和个数）=> 函数实现和返回值类型
“=” 表示将函数赋给一个变量
“=>” 左边表示输入参数名称、类型和个数，右边表示函数的实现和返回值。
匿名函数
在 Scala 中，你不需要给每一个函数命名，没有将函数赋给变量的函数叫做 匿名函数
object anonFunction {
def main(args: Array[String]): Unit = {
//定义一个数组
val arr: Array[Int] = Array(1, 2, 3, 4)
//map里面的就是匿名函数
val map: Array[Int] = arr.map((x: Int) => {
x * 2
})
map.foreach(line => {
println(line)
})
}
}
由于 Scala 可以自动推断出参数的类型，所以写的更精简一些
//map里面的就是匿名函数
val map: Array[Int] = arr.map(x => {
x * 2
})
使用下划线的话 可以更精简一点
val map: Array[Int] = arr.map(_ * 2)
递归函数
/**
* 递归函数
* 5的阶乘
*/
def fun2(num :Int) :Int= {
if(num ==1)
num
else
num * fun2(num-1)
}
print(fun2(5))
嵌套函数
/**
* 嵌套函数
* 例如：嵌套函数求5的阶乘
*/
def fun5(num:Int)={
def fun6(a:Int,b:Int):Int={
if(a == 1){
b
}else{
fun6(a-1,a*b)
}
}
fun6(num,1)
}
println(fun5(5))
25、柯里化
什么是柯里化
==柯里化（Currying）==指的是把原来接受多个参数的函数变换成接受一个参数的函数过程，并且返回接受余下的参数且返回结果为一个新的函数的技术。
例子
- 一个普通的非柯里化的函数定义，实现一个加法函数：
scala> def plainOldSum(x:Int,y:Int)=x+y
plainOldSum: (x: Int, y: Int)Int
scala> plainOldSum(1,2)
res0: Int = 3
- 使用“柯里化”技术来定义这个加法函数，原来函数使用一个参数列表，“柯里化”，吧函数定义为多个参数列表：
scala> def curriedSum(x:Int)(y:Int)=x+y
curriedSum: (x: Int)(y: Int)Int
scala> curriedSum(1)(2)
res1: Int = 3
当你调用curriedSum (1)(2)时，实际上是依次调用两个普通函数（非柯里化函数），
第一次调用使用一个参数x，返回一个函数类型的值，
第二次使用参数y调用这个函数类型的值
- 使用下面两个分开的定义在模拟 curriedSum 柯里化函数。
首先定义第一个函数：
scala> def first(x:Int)=(y:Int)=>x+y
first: (x: Int)Int => Int
然后我们使用参数1调用这个函数来生成第二个函数：
scala> val second =first(1)
second: Int => Int = <function1>
scala> second(2)
res2: Int = 3
- 使用 curriedSum 来定义 second
scala> val onePlus=curriedSum(1)_
onePlus: Int => Int = <function1>
下划线“_” 作为第二参数列表的占位符， 这个定义的返回值为一个函数，当调用时会给调用的参数加一。
scala> onePlus(2)
res3: Int = 3
调用生成的函数，给函数传入参数，即可得到我们想要的结果。
总结
Scala 柯里化风格的使用可以简化主函数的复杂度，提高主函数的自闭性，提高功能上的课扩张性、灵活性。可以编写出更加抽象、功能化和高效的函数式代码。
26、隐式转换和隐式参数
隐式转换
Scala 提供的隐式转换和隐式参数功能，是非常有特色的功能。是 Java 等编程语言所没有的功能。他可以允许你手动指定，将某种类型的对象转换成其他类型的对象或者是给一个类增加方法。通关这些功能可以实现非常强大、特殊的功能。其中所有的隐式值和隐式方法必须放到 object 中。
然而使用 Scala 的隐式转换有一定的限制的，总结如下：
- implicit 关键字只能用来修饰 方法、变量（参数）。
- 隐式转换的方法在当前范围内才有效。如果隐式转换不在当前范围内定义（比如定义在另一个类中或包含在某个对象中），那么必须通过 import 语句将其导入
//通过这种方式导入
类名.方法
import Scala01.f1
- 隐式转换函数名可以是任意的，隐式转换与函数名有关，只与函数参数类型和返回值类型有关。
- 隐式函数可以有多个，就是隐式函数列表，但是必须保证当前环境下，只有一个隐式函数功能被识别。
object Scala03 {
def main(args: Array[String]): Unit = {
implicit def f1(double: Double): Int ={
double.toInt
}
implicit def f2(double: Double): Int = {
double.toInt
}
implicit def f3(float: Float): Int ={
float.toInt
}
val a:Int=2.34
}
}
对象转换案例一
优雅的解决数据类型转换问题
object Scala01 {
//定义一个隐式转换的方法 实现double-->int
implicit def f1(d: Double): Int = {
d.toInt
}
def main(args: Array[String]): Unit = {
//转换成功
val a: Int = 4.5
val b: Int = 5.6
}
def function01(): Unit ={
val c:Int=1.123123
}
对象装换案例二
通过隐式转换丰富我们类库的功能
如果为一个动态的增加一个方法，可以通过隐式转换的形式来实现（动态增加功能）OCP(Open-Closed Principle）原则：对修改关闭，对扩张开放
给Mysql类增加一个delete方法
/**
* 动态的给Mysql增加delete 方法
*/
object Scala04 {
def main(args: Array[String]): Unit = {
//隐式方法
implicit def addDelete(mysql: Mysql): DB = {
new DB
}
//创建msyql
val mysql: Mysql = new Mysql()
mysql.insert()
//增加一个删除的方法
mysql.delete()
}
}
class Mysql {
def insert(): Unit = {
println("insert into data database")
}
}
class DB {
def delete(): Unit = {
println("delete data from database")
}
}
扩展知识
- 隐式转换案例一（让 File 类具备 RichFile 类中的 read 方法）
import java.io.File
import scala.io.Source
object MyPredef{
//定义隐式转换方法
implicit def file2RichFile(file: File)=new RichFile(file)
}
class RichFile(val f:File) {
def read()=Source.fromFile(f).mkString
}
object RichFile{
def main(args: Array[String]) {
val f=new File("E://words.txt")
//使用import导入隐式转换方法
import MyPredef._
//通过隐式转换，让File类具备了RichFile类中的方法
val content=f.read()
println(content)
}
}
隐式转换案例二（超人变身）
class Man(val name:String)
class SuperMan(val name: String) {
def heat=print("超人打怪兽")
}
object SuperMan{
//隐式转换方法
implicit def man2SuperMan(man:Man)=new SuperMan(man.name)
def main(args: Array[String]) {
val hero=new Man("hero")
//Man具备了SuperMan的方法
hero.heat
}
}
隐式转换案例三（一个类隐式转换成具有相同方法的多个类）
class A(c:C) {
def readBook(): Unit ={
println("A说：好书好书...")
}
}
class B(c:C){
def readBook(): Unit ={
println("B说：看不懂...")
}
def writeBook(): Unit ={
println("B说：不会写...")
}
}
class C
object AB{
//创建一个类的2个类的隐式转换
implicit def C2A(c:C)=new A(c)
implicit def C2B(c:C)=new B(c)
}
object B{
def main(args: Array[String]) {
//导包
//1. import AB._ 会将AB类下的所有隐式转换导进来
//2. import AB._C2A 只导入C类到A类的的隐式转换方法
//3. import AB._C2B 只导入C类到B类的的隐式转换方法
import AB._
val c=new C
//由于A类与B类中都有readBook()，只能导入其中一个，否则调用共同方法时代码报错
//c.readBook()
//C类可以执行B类中的writeBook()
c.writeBook()
}
}
隐式参数案例四（隐式的变量）
object Company{
//在object中定义隐式值 注意：同一类型的隐式值只允许出现一次，否则会报错
implicit val aaa="zhangsan"
implicit val bbb=10000.00
}
class Boss {
//注意参数匹配的类型 它需要的是String类型的隐式值
def callName()(implicit name:String):String={
name+" is coming !"
}
//定义一个用implicit修饰的参数
//注意参数匹配的类型 它需要的是Double类型的隐式值
def getMoney()(implicit money:Double):String={
" 当月薪水："+money
}
}
object Boss extends App{
//使用import导入定义好的隐式值，注意：必须先加载否则会报错
import Company._
val boss =new Boss
println(boss.callName()+boss.getMoney())
}
27、Scala中函数和方法区别
- 方法不能作为单独的表达式二存在，但是函数可以。
- 函数必须有参数列表，就算是空的也需要写上，方法可以没有。
函数的定义：
val sqlName = () => {
println(“他的名字叫 :” +)
}
方法的定义:
def eat: Unit = {
println(“在吃东西------------”)
} - 方法不是值，函数是值，不能把方法赋值给变量 val ，函数可以赋给一个变量
- 方法可以转化为函数，函数不能转为方法
val cc = eat _ 把方法转为函数
嵌套函数和递归函数的区别
递归调用是自己调用自己，函数嵌套是可以调用其他函数
扫一扫
1526
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
