Scala 方法的定义声明

2019-05-01 17:05:35 | 编辑

1.使用默认值定义方法

前面已经介绍过case class,这次就用起来作为案例,定义Point 类,并提供默认的初始化值,定义新的shift 方法,用于从现有的Point 对象中对“点”进行平移,从而创建一个新的Point 对象。它使用了copy 方法,copy 方法也是case 类自动创建的。

case class Point(x: Double = 0.0, y: Double = 0.0) {
def shift(deltax: Double = 0.0, deltay: Double = 0.0) = copy (x + deltax, y + deltay)
}


2.使用命名参数列表

copy 方法允许你在创建case 类的新实例时,只给出与原对象不同部分的参数,这一点对于大一些的case 类非常有用:

scala> val p1 = new Point(x = 3.3, y = 4.4) // 显式使用命名参数列表。
p1: Point = Point(3.3,4.4)
scala> val p2 = p1.copy(y = 6.6) // 指定新的y值,创建新实例。
p2: Point = Point(3.3,6.6)

命名参数列表让客户端代码更具可读性。当参数列表很长,且有若干参数是同一类型时,bug 容易避免,因为在这种情况下很容易搞错参数传入的顺序。当然,更好的做法是一开始就避免出现过长的参数列表。


3.定义方法具有多个参数列表

abstract class Shape() {
/**
* draw 带两个参数列表,其中一个参数列表带着一个表示绘制偏移量的参数
* 另一个参数列表是我们之前用过的函数参数。
*/
def draw(offset: Point = Point(0.0, 0.0))(f: String => Unit): Unit =
f(s"draw(offset = $offset), ${this.toString}")
}

这里的draw 方法有两个参数列表,这个拥有两个List参数是不一样的,第一个参数列表的参数允许你指定Point 对象,第二个参数列表是用来绘制所用的函数的函数参数

你可以任意指定参数列表的个数,但实际上很少有人使用两个以上的参数列表。


3.1优点一:更优雅

那么,为什么要允许多个参数列表呢?当最后一个参数列表只包含一个表示函数的参数时,多个参数列表的形式拥有整齐的块结构语法。以下是我们调用新的draw 方法的表达方式:

s.draw(Point(1.0, 2.0))(str => println(s"ShapesDrawingActor: $str"))

Scala 允许我们把参数列表两边的圆括号替换为花括号,因此,这一行代码还可以写为:

s.draw(Point(1.0, 2.0)){str => println(s"ShapesDrawingActor: $str")}

如果函数字面量不能在一行内完成,我们可以重写为以下方式:

s.draw(Point(1.0, 2.0)) { str =>
println(s"ShapesDrawingActor: $str")
}

或写为等价的形式:

s.draw(Point(1.0, 2.0)) {
str => println(s"ShapesDrawingActor: $str")
}

这一写法很像我们之前常用来写if 和for 表达式或方法体的代码块。只不过,在这里的{…} 块所表示的函数是我们要传递给draw 方法的参数

当函数字面量很长时,这种用{…} 代替(…) 的“语法糖”使得代码看起来美观多了。此时的代码更像我们所熟悉和喜爱的块结构语法。如果我们使用缺省的偏移量,第一个圆括号就不能省略:

s.draw() {
str => println(s"ShapesDrawingActor: $str")
}

如同Java 方法一样,draw 方法也可以只使用一个带两个参数值的参数列表。如果那样,客户端代码就会像这样写:

s.draw(Point(1.0, 2.0),
str => println(s"ShapesDrawingActor: $str")
)

这份代码并没那么清晰和优雅。使用默认值开启offset 也没那么便捷,因此我们不得不对参数进行命名:

s.draw(f = str => println(s"ShapesDrawingActor: $str"))


3.2 第二个优势是在之后的参数列表中进行类型推断。如以下例子:

scala> def m1[A](a: A, f: A => String) = f(a)
m1: [A](a: A, f: A => String)String
scala> def m2[A](a: A)(f: A => String) = f(a)
m2: [A](a: A)(f: A => String)String
scala> m1(100, i => s"$i + $i")
<console>:12: error: missing parameter type
m1(100, i => s"$i + $i")
scala> m2(100)(i => s"$i + $i")
res0: String = 100 + 100

函数m1 和函数m2 看起来几乎一模一样,只不过m1是两个参数,而m2有两个参数列表,但我们需要注意用相同的参数调用它们时m1 和m2 的表现。我们传入Int 和一个函数Int => String,对于m1,Scala 无法推断该函数的参数i,m2 则可以。


3.3使用多个参数列表的第三个优势是,我们可以用最后一个参数列表来推断隐含参数。隐含参数是用implicit 关键字声明的参数。当相应方法被调用时,我们可以显式指定这个参数,或者也可以不指定,这时编译器会在当前作用域中找到一个合适的值作为参数。隐含参数可以代替参数默认值,而且更加灵活。


4.可变长参数值

println()这样的方法可接受变长参数值。可以传递零个、一个或者多个参数值给这样的方法。在Scala 中,你可以方便地创建接受变长参数值的函数。我们可以设计接受变长参数值的方法。但是,如果我们有多个参数,那么只有最后一个参数可以接受变长参数值。我们可以在最后一个参数类型后面加上星号,以表明该参数(parameter)可以接受可变长度的参数值(argument)。下面以函数max()为例。

def max(values: Int*) = values.foldLeft(values(0)) { Math.max }

调用 max()函数的示例如下所示。

max(8, 2, 3)

在上面的例子中,我们只给函数传递了 3 个参数值,我们也可以传递更多参数值。下面看一个例子

max(2, 5, 3, 7, 1, 6)

当参数的类型使用一个尾随的星号声明时,Scala 会将参数定义成该类型的数组。让我们用下面的例子来进行验证

def function(input: Int*): Unit = println(input.getClass)
function(1, 2, 3)

可以用任意数量的参数调用 max()函数。因为参数类型是数组,所以我们可以使用迭代器来处理接收到的参数的集合。将数组而非离散值作为参数值传入好像很吸引人,但是并不能这样做。例如,下面这个例子:

val numbers = Array(2, 5, 3, 7, 1, 6)
max(numbers) // 类型匹配错误

上面的代码将会产生如下编译错误:

CantSendArray.scala:5: error: type mismatch;
found : Array[Int]
required: Int
max(numbers) // 类型匹配错误
one error found


类型不兼容是导致这个错误的主要原因。这个参数很像数组,但不是字面上的数组类型,而参数值现在是一个数组。然而,如果我们有一组值,那么我们更希望直接传递数组。我们

可以使用数组展开标记(array explode notation),像这样:

val numbers = Array(2, 5, 3, 7, 1, 6)
max(numbers: _*)

参数名后面的一系列符号告诉编译器将数组展开成所需的形式,以传送变长参数值。

现在我们已经知道了如何将变长参数值传递给方法。


5.嵌套方法的定义与递归

方法的定义还可以嵌套。当你将一个很长的方法重构为几个更小的方法时,如果这些小的辅助方法只在该方法中调用,就可以用嵌套方法。我们将这些辅助函数嵌套定义在原方法中,它们便对其他外层的代码不可见,包括类中的其他方法。以下代码实现了阶乘的计算,在这个方法中,我们调用了另一个嵌套的方法去完成阶乘的实际计算:

// src/main/scala/progscala2/typelessdomore/factorial.sc
def factorial(i: Int): Long = {
def fact(i: Int, accumulator: Int): Long = {
if (i <= 1) accumulator
else fact(i - 1, i * accumulator)
}
fact(i, 1)
}
(0 to 5) foreach ( i => println(factorial(i)) )

以下为代码运行的输出:

1
1
2
6
24
120

辅助函数递归地调用它本身,并传入一个accumulator 参数,阶乘的计算结果保存在该参数中。注意,当计数器i 达到1 时,我们就将阶乘的计算结果返回。(这里我们不考虑负整数参数,负整数的输入是无效的,本函数在i <= 1 时返回1。)定义好嵌套的方法后,factorial 调用该方法,传入参数i,并累计乘法的初始值1。

很容易忘记调用嵌套的函数!如果编译器提示,能找到Unit 但找不到Long,可能就是因为你忘记调用嵌套函数了。


是否注意到,我们两次用i 作为参数名?第一次是factorial 方法的参数,第二次是嵌套的fact 方法的参数。在fact 方法中使用的i 参数“屏蔽”了外部factorial 方法的i 参数。这样做是允许的,因为我们在fact 方法中并不需要外部的i,我们只在factorial 结尾调用fact 的时候才需要它。类似方法中声明的局部变量,嵌套的方法也只在声明它的方法中可见。观察这两个方法的返回值。因为阶乘的计算结果增长非常快,我们选择使用Long 类型,而不使用Scala 自动推断的Int 类型。如果使用Int 类型,factorial 就不需要上述的类型注释了。然而,我们必须要为fact 声明返回类型。因为这是一个递归方法,Scala 采用的是局部作用域类型推断,无法推断出递归函数的返回类型。


对递归函数你也许会感到一丝不安。我们是否在冒风险? JVM 和许多其他语言环境并不对尾递归做优化,否则尾递归会将递归转为循环,可以避免栈溢出。(尾递归一词,表示调用递归函数是该函数中最后一个表达式,该表达式的返回值就是所调用的递归函数的返回值。)


递归是函数式编程的特点,也是优雅地实现很多算法的强大工具。所以,Scala 编译器对尾递归做了有限的优化。它会对函数调用自身做优化,但不会优化所谓的trampoline 的情况,也就是“a 调用b 调用a 调用b”的情形。


你可能仍然想知道自己写的尾递归是否正确,编译器是否对自己的尾递归执行了优化。没有人希望在生产环境中出现栈空间崩溃。幸运的是,如果你加一个tailrec 关键字(http://www.scala-lang.org/api/current/#scala.annotation.tailrec),编译器会告诉你代码是否正确地实现了尾递归,如以下factorial 的改良版本:

// src/main/scala/progscala2/typelessdomore/factorial-tailrec.sc
import scala.annotation.tailrec
def factorial(i: Int): Long = {
@tailrec
def fact(i: Int, accumulator: Int): Long = {
if (i <= 1) accumulator
else fact(i - 1, i * accumulator)
}
fact(i, 1)
}
(0 to 5) foreach ( i => println(factorial(i)) )


如果fact 不是尾递归,编译器就会抛出错误。我们用这个特性在REPL 中写出递归的Fibonacci 函数:

scala> import scala.annotation.tailrec
scala> @tailrec
| def fibonacci(i: Int): Long = {
| if (i <= 1) 1L
| else fibonacci(i - 2) + fibonacci(i - 1)
| }
<console>:16: error: could not optimize @tailrec annotated method fibonacci:
it contains a recursive call not in tail position
else fibonacci(i - 2) + fibonacci(i - 1)

我们有两个递归调用,然后又对调用的结果做计算,而不是只在结尾调用一次递归函数,因此这个函数不是尾递归的。

最后要说明的是,外层方法所在作用域中的一切在嵌套方法中都是可见的,包括传递给外层方法的参数。