Scala学习之路三

scala的函数

1 函数的定义

Scala除了方法外还支持函数。方法对对象进行操作，函数不是。要定义函数，你需要给出函数的名称、参数和函数体，就像这样：

说明：

1. 必须给出所有参数的类型。不过，只要函数不是递归的，就不需要指定返回类型。Scala编译器可以通过 = 符号右侧的表达式的类型推断出返回类型。
2. “=”并不只是用来分割函数签名和函数体的，它的另一个作用是告诉编译器是否对函数的返回值进行类型推断！如果省去=,则认为函数是没有返回值的！
3. 在scala中一个函数的最后一句话就是该函数的返回值，不需要使用return，当然加上也行。

object funcTest {
	def main(args: Array[String]): Unit = {
//		show()
		val ret = sayHi("goodera")
		println(ret)
	}

	def show() = {
		println("abcde")
	}

	def sayHi(name:String) = {
		"Nice to meet you, " + name
	}
}

说明：函数可以不使用return语句，但是如果加上return，那返回值类型，必须要加上，否则：

def sayHi(name:String):String = {
    return "Nice to meet you, " + name
}

2 特殊函数

• 单行函数:所谓单行函数，指的是函数体只有一行的函数

def sayHello(name:String) = println("Nice to meet you, " + name)

注意：单行函数，必须要使用"="来做函数的返回值类型推断。

• 无参函数:函数的参数列表为空

def show() = {
    println("goodera")
}

注意：定义空参函数的时候，如果函数加了()，在调用的时候，()可以省略；但是如果在定义的时候没有加()，在调用的时候，也只能省略，不能加()。

• 递归函数:在特定条件下，函数调用本身
  阶乘求解：5!

/**
	  * 阶乘
	  * n!= n * (n-1)*..*2*1
	  * n!= n * (n-1)!
	  * 1！ = 1
	  */
def factorial(n:Int):Int = {
    if(n == 1)
    1
    else
    n * factorial(n - 1)
}

3 函数参数的特点

3.1 默认参数和带名参数

def main(args: Array[String]): Unit = {
    showAddr("Goodera", 1688888168, "广西", "CRP")//会覆盖默认值
    showAddr("Lin", 1381638338, "广东")//使用默认值
    //传递参数的时候，可以指定具体的参数名称
    showAddr(phone = 1395959599L, name = "zhangsan", province = "lisi")
}

def showAddr(name:String, phone:Long, province:String, country:String = "CHINA"): Unit = {
    println(s"name=$name, phone=$phone, province=$province, country=$country")
}

scala的函数参数列表，在定义的时候，可以使用有默认值的参数，在做函数调用的时候可以使用带名的参数，所以有时我们是无法通过函数传递的参数来推断出具体的参数列表顺序。

3.2 可变参数

java版本的可变参数：

public class VariableParam {
    public static void main(String[] args) {
        Calc calc = new Calc();
        System.out.println(calc.add(1, 3));
        System.out.println(calc.add(1, 3, 5));
        System.out.println(calc.add(new int[]{1, 3, 5, 7}));
        System.out.println(calc.add(1, 3, 5, 7, 9));
    }
}

class Calc {
    public int add(int a, int b) {
        return a + b;
    }

    public int add(int a, int b, int c) {
        return a + b + c;
    }
    //数组
//    public int add(int[] arr) {
//        int sum = 0;
//        for(int i : arr) {
//            sum += i;
//        }
//        return sum;
//    }
    //可变参数
    public int add(int ... arr) {
        int sum = 0;
        for(int i : arr) {
            sum += i;
        }
        return sum;
    }
}

scala版本：

//scala中的可变参数
object  VariableParam {
	def main(args: Array[String]): Unit = {
		println(add(1, 2, 3))
		println(add(1, 2, 3, 5))
		//声明scala中的一个数组
		val a = Array(3, 4, 5)
		println(add(a: _*))
	}

	def add(arr: Int*) = {
		var sum = 0
		for(a <- arr) {
			sum += a
		}
		sum
	}
}

说明：

1. scala中的可变参数和java有一点不同，上例中第三个函数和第四个函数，在java中实际上是同一个函数，而在scala中是两个不同的函数。
2. 在对函数add(arr:Int*)就不能向java一样，直接传递一个数组，否则报错，类型不匹配。要想给一个可变参数传递数组，就需要将数组中的元素提取出来，再传递，操作方式如下：

val arr = Array(3, 4, 5)
ret = add(arr: _*)