SCALA函数总结

1. 如果函数体只有一行代码，则可以不用写{},比如

Java代码  

1. def print(x: Int) = println(x)  

一行上的多条语句用分号隔开，则只有第一句属于方法体，例如

 

Java代码  

1. def printWithValue(x: Int) : String= println(x); "ABC"  

 

上面的代码报错，因为，printWithValue的方法体只有一句代码println(x),而它结果值是Unit，因此指定printWithValue返回String，出现类型返回错误。如果将两条语句包在一起，则正确

 

Java代码  

1. def printWithValue(x: Int) : String= {println(x); "ABC"}  

 

 

 

 

 

2.无参函数，在调用时，不需要写()，直接写函数名即是方法调用。则代码中写print和print()都是方法调用

 

Java代码  

1. def print() = println(100)  

 

3. 如果方法明确的指定了返回值的类型，则必须在返回值类型后加等于号，否则可以不加也可以加

 

Java代码  

1. def noReturn() = {  
2.   println("100");  
3. }  

 也可以写成：

Java代码  

1. def noReturn() {  
2.   println("100");  
3. }  

 

如下写法是不正确的：

 

Java代码  

1. def noReturn():Unit {  
2.   println("100");  
3. }  

 必须写成：

Java代码  

1. def noReturn() :Unit = {  
2.   println("100");  
3. }  

 因此，好的习惯是不论有无返回值，都加=

 

4.默认函数值，必须出现在最后，即带有默认值的参数后不能再有不带默认值的参数了

 

Java代码  

1. def add(a: Int, b: Int = 20, c: Int = 30): Int = {  
2.   a + b + c  
3. }  

 

下面的写法，不报错，但是调用add(100)则报错

Java代码  

1. def add(a: Int = 20, b: Int, c: Int = 30): Int = {  
2.   a + b + c  
3. }  

 

5. 变长参数，使用T*表示

 

Java代码  

1. def sum(elems: Int*) : Int = {  
2.   var sum = 0;  
3.   elems.foreach(elem => sum += elem)  
4.   sum  
5. }  

 下面的写法则报错：

 

Java代码  

1. def sum(elems: Int*) : Int = {  
2.   var sum = 0;  
3.   elems.foreach(_ => sum += _)  
4.   sum  
5. }  

 提示，sum += _不正确

 

Java代码  

1. Error:(61, 31) missing parameter type for expanded function ((x$2) => sum.<$plus$eq: error>(x$2))  
2.     elems.foreach(_ => sum += _)  
3.                               ^  

 

如下写法是正确的，使用_指代循环的变量，简单的写法：

 

Java代码  

1. def sum(elems: Int*) : Int = {  
2.   var sum = 0;  
3.   elems.foreach(sum += _)  
4.   sum  
5. }  

 

 

6. 方法抛异常，无需检查Checked Exception

Java代码  

1. def exceptionProcessing() {  
2.   try {  
3.     throw new Exception("error");  
4.   } catch {  
5.     case e:IllegalArgumentException => println("IAE" + e.getMessage)  
6.     case e: NullPointerException => println("NPE" + e.getMessage);  
7.     case e: Exception => throw e //如果是Exception，则重新抛出  
8.   }  
9. }  

 

7. 带有多个（参数）的函数，柯力化

 

Java代码  

1. def addXY(x:Int)(y:Int) : Int= {  
2.   x + y  
3. }  

 通过如下调用：addXY(1)(2)

 

8. 函数赋值

 

Java代码  

1. def addXY(x:Int)(y:Int) : Int= {  
2.   x + y  
3. }  

 

Java代码  

1. val copyOfAddXY = addXY(1)(_)  
2. println(copyOfAddXY(3))  

 结果是4，这表示部分应用函数，如果不加(_)则是不正确的

 

9，部分应用函数：

Java代码  

1. def substract(a: Int, b: Int, c: Int): Int = {  
2.   a + b - c  
3. }  

 则如下的第一个赋值是正确的，剩下的两个都不正确，

 

Java代码  

1. var func1 = substract(_,_,_) ///正确  
2. println(func1(1,5,3))  
3. func1 = substract(2,_,_) //提示：Wrong number of parameters, expected  
4. println(func1(8,3));  
5. func1 = substract(3,_,9)//提示：Wrong number of parameters, expected  
6. println(func1(100))  

 

10. 闭包

Java代码  

1. def closure(x :Int) :Int => Int ={  
2.     def sum(y:Int) :Int = {  
3.       x + y //x is not in the scoped of the  
4.     }  
5.   sum  
6. }  

 

调用closure(10)(100)，注意Int=>Int是函数sum的类型，即输入为Int，输出也为Int

 

11.

 

Java代码  

1. def myValue = {  
2.   val a = 10  
3.   a + 10  
4. }  

 调用时，println(myValue)正确，println(myValue())则报错，原因是myValue不是函数，因为定义时没有加括号def myValue而不是def myValue()，这里的myValue是一个值，块表达式。那么它的效果跟如下定义一个使用块表达式表示的变量是一样的

 

 

Java代码  

1. val myValue = {  
2.   val a = 10  
3.   a + 10  
4. }  

 

 

12

Java代码  

1. def myFunc() = {  
2.   val a = 10;  
3.   a + 10  
4. }  

 println(myFunc())为什么打印20，因为myFunc没有指明返回值的类型，那就默认是Unit?这个理解是错误的，Scala的函数定义也可以自动推导函数的返回类型，一个函数是否有返回值，看参数列表()和方法体{}之间是否有等号，有等号，则把

最后一个语句的返回值作为函数的返回值(尽管没有显式指定函数的返回值)，如果没有使用等号，那么函数一律返回Unit