1.传值调用和传名调用
Scala的解析器在解析函数参数时有两种方式：
- 传值调用（call by value）：先计算参数表达式的值，再应用到函数内部；
- 传名调用（call by name）：将未计算的参数表达式直接应用到函数内部。
在进入函数内部之前，传值调用方式就已经将参数表达式的值计算完毕，而传名调用是在函数内部进行参数表达式的值计算的。这就造成了一种现象，每次使用传名调用时，解释器都会计算一次表达式的值。
传值调用的函数的格式如下：
def FuncName(var: varType)[: retType = ]{
Function-Body
[return ]retVal
}
传值调用比较简单，这里就不再举例说明。下面来看传名调用。
传名调用的函数的格式如下：
def FuncName(var: => varType)[: retType = ]{
Function-Body
[return ]retVal
}
举个例子：下面示例演示了传名调用函数的使用方法：
object Test1 {
def main(args: Array[String]) {
delayed(time());
}
def time(): Long = {
println("get time and unit is ns");
return System.nanoTime;
}
def delayed(t: => Long) {
println("in method delayed()");
println("time：" + t + " ns");
t;
}
}
以上实例中我们声明了delayed方法，该方法在变量名和变量类型之间使用=>符号来表示传名调用。编译执行以上代码，输出结果如下：
E:\Scala>scalac Test1.scala
E:\Scala>scala Test1
in method delayed()
get time and unit is ns
time: 86979160221908 ns
get time and unit is ns
这里需要注意3点：
- 函数的返回值前面的return关键字可以省略，此时函数最后一条语句就是返回值。如：time()函数的返回值为System.nanoTime; delayed()函数的返回值为t;
- 函数的返回值类型可以省略，此时会根据实际返回值的类型推测函数的类型；如：time()函数的类型显示指定为Long；delayed()函数的返回值的类型就是t的类型。
- 如果函数有返回值，且调用者用到了该返回值，则函数名和函数体之间的等号”=”不能省略，否则编译出错；如果没有返回值，或者调用者没有用到该返回值，则等号可以省略。如time()函数有返回值，且调用者delayed()函数用到了该返回值，所time()函数中等号”=”不能省略；而delayed()函数虽然有返回值，但是调用者main()函数并没有用到该返回值，所以delayed()函数中的等号”=”可以省略。
2.调用时指定参数名
一般情况下，调用一个函数，按照函数定义时的参数顺序传递参数即可。但是也可以通过指定函数参数名，这时不需要按照既定顺序传递参数。实例如下：
object Test2 {
def main(args: Array[String]) {
printInt(b=5, a=7);
}
def printInt( a:Int, b:Int ) = {
println("Value of a : " + a );
println("Value of b : " + b );
}
}
编译并执行以上代码，输出结果为：
E:\Scala>scalac Test2.scala
E:\Scala>scala Test2
Value of a: 7
Value of b: 5
从上面例子可以看出，我们定义函数时，参数a在参数b的前面，但是调用函数时，指定了参数名就可以不考虑传参的顺序。
3.可变参数
Scala允许你指明函数的最后一个参数可以是重复的，即我们不需要指定函数参数的个数，可以向函数传入可变长度参数列表。Scala通过在参数的类型之后放一个星号”*”，来设置可变参数（即可重复的参数）。示例如下：
object Test3 {
def main(args: Array[String]) {
printStrings("Hello World","Hello Scala","I love Scala");
}
def printStrings(args:String*)={
var i:Int = 0;
for( arg <- args){
println("Arg value["+i+"] = "+arg);
i = i+1;
}
}
}
编译并执行以上代码，输出的结果如下：
E:\Scala>scalac Test3.scala
E:\Scala>scala Test3
Arg value[0] = Hello World
Arg value[1] = Hello Scala
Arg value[2] = I love Scala
4.Scala递归函数
递归函数就是自己可以调用自己的函数。递归函数在函数式编程语言中起着重要的作用。Scala作为一门函数式编程语言，同样支持递归函数。下面实例演示了Scala中的递归函数的实现：使用递归函数求阶乘：
object Test4 {
def main(args: Array[String]) {
for (i <- 1 to 10)
println("factorial[" + i + "] = " + factorial(i) );
}
def factorial(n: BigInt): BigInt = {
if (n <= 1)
1;
else
n * factorial(n - 1)
}
}
编译并执行以上代码，输出结果如下：
E:\Scala>scalac Test4.scala
E:\Scala>scala Test4
factorial[1] = 1
factorial[2] = 2
factorial[3] = 6
factorial[4] = 24
factorial[5] = 120
factorial[6] = 720
factorial[7] = 5040
factorial[8] = 40320
factorial[9] = 362880
factorial[10] = 3628800
5.默认参数值
Scala可以为函数参数指定默认参数值，使用了默认参数，在调用过程中可以不需要传递参数，函数会自动使用默认参数值，如果传递了参数，则使用传递的参数，而不是默认参数。实例如下：
object Test5 {
def main(args:Array[String]){
addInt(1,2,3);
addInt(1,2);
addInt(1,c=3);
addInt(1);
//addInt(b=2); //wrong
//addInt(c=3); //wrong
//addInt(); //wrong
}
def addInt(a:Int, b:Int=5, c:Int=7){
var sum:Int = 0;
sum = a + b + c;
println(a + "+" + b + "+" c + "=" + sum);
}
}
编译并执行以上代码，输出结果如下：
E:\Scala>scalac Test5.scala
E:\Scala>scala Test5
1+2+3=6
1+2+7=10
1+5+3=9
1+5+7=13
关于默认参数有以下几点说明：
- 定义时，默认参数一定要在普通参数之后，如：addInt(a:Int, b:Int=5, c:Int=7)；
- 调用时，普通参数必须传值，否则编译出错，如：addInt(b=2);或者addInt();
- 调用时，如果传参个数多余普通参数个数，则剩余参数从前往后赋值给默认参数，没有赋值到默认参数使用默认值，如：addInt(1,2);
- 调用时，如果传参个数多余普通参数个数，则剩余参数可以指定参数名来打破默认的“从前到后”的传参顺序，如：addInt(1,c=3);
