Scala基础之函数

朴灿烈づ我的快乐病毒、 2022-08-24 05:24 136阅读 0赞

**Scala基础之函数：**

**    Scala除了方法，还支持函数。方法对对象进行操作，函数不是。**

**     定义函数，需要给出函数的名称、参数和函数体。如：**

**      def sum(x:int) = if(x>=0) x else -x**

**      函数需要给出所有参数的类型。只要函数不递归，就不需要知道返回列下。Scala可以根据=号右侧表达式推导出放回类型。**

**      如果函数体需要多个表达式完成，可以使用代码块。块的最后一个表达式的值就是函数的返回值。如：**

**        **

def sum(n:Int) = {
    		var r =1
                    for (i <- 1 to 10) 
                          r = r*i
                          r
               }

**         此函数r即是函数的返回值。如果使用return返回r的值，那么需要明确指定函数返回类型，如下所示：**

**         **

def sum(n:Int):Int = {
    		var r =1
                    for (i <- 1 to 10) 
                          r = r*i
                         return r
               }

**          其与上面的是一样的，只是上面的写法更简洁。**

**     如果是递归函数，同样需要指定返回类型。如：**

**   **

def fac(n:Int):Int = if( n <= 0) 1 else n*fac(n-1)
        
         println(fac(5)) //120

**默认参数和代码参数：**

**     **

**有些情况下我们不需要给出全部参数，对应这类函数我们可以使用默认参数，当然你需要知道参数顺序或者参数名称。如：**

**         **

def outputBookName(bookname:String,left:String="{",right:String="}") =
          left + bookname + right
        
        println(outputBookName("book1"))
        
        println(outputBookName("book2", "[", "]"))
        
        println(outputBookName(right="***]",bookname="book3"))

输出：

**       \{book1\}   --》使用了默认参数  
        \[book2\]    --》 使用了传入的参数  
        \{book3\*\*\*\] --》根据需要，提供参数名称和值替换默认值**

**变长参数：**

**      实现一个可以接受可变长度的参数列表的函数，如：**

**    **

def sum1(args : Int*) = {
          var result = 0
          for(arg <- args)
             result += arg
             result
        }
        
        println(sum1(5,4,3,2,1)) //15

**   实现一个序列作为参数传入上述函数中，需要追加 \_\*，告诉编译器希望把这个参数当做序列处理。如：**

** **

val s = sum1(1 to 5: _*)  //将1到5当做参数序列处理

** 在递归中我们同样可以使用这种方式，如：**

** **

def sum2(args : Int*):Int = {
           if(args.length == 0 )
             0
           else
             args.head + sum2(args.tail: _*)
        }

序列的head是参数args的首个元素，而tail是所有其它的元素序列，这是个Seq，需要用 \_\*将它转为参数序列。

**过程：**

**   定义：**

**    Scala对不返回值的函数有特殊的表示法。如果函数体包含在花括号中但没有前面的=号，那么返回类型是Unit。这样的函数叫做过程。**

**过程不返回值，我们调用它是为了使用它的副作用。如：我们需要打印一些图案，那么可以定义一个过程：**

** **

def draw(s:String) {
          
          println("-------")
          println("|"+"   "+"|")
          println("|"+s+"|")
          println("|"+"   "+"|")
          println("-------")
        }
        
        println(draw("123"));
    
    输出：
    
    -------
    |   |
    |123|
    |   |
    -------
    ()

**看上面的返回，可以明显的指定这个函数的返回值是Unit；**

**懒值：**

**     当val被声明为lazy时，它的初始化将被推迟，知道我们首次取它的值。如：**

**    **

lazy val file1 = scala.io.Source.fromFile("C:/hello.scala").mkString
        
        println(file1)

输出：

**println("hello")**

**如果我们不调用**

println(file1)

**  这行语句，即file1不被访问，那么文件就不会被打开。**

**    **

**异常：**

** Scala异常的工作机制同Java。当你需要抛出异常时，如：**

**   throw new FileNotFoundException（"系统找不到指定的文件。"）**

**Scala异常同Java一样，抛出的异常必须是java.lang.Throwable的子类。其与Java不同的是，Scala没有受检异常，不需要声明函数或者方法可能会抛出异常。**

**throw 表达式有特殊类型Nothing。这在if else表达式中很有用。如果一个分支的类型是Nothing，那么if else表达式的类型就是另外一个分支的类型。**

**捕获异常的语法采用模式匹配的语法。如：**

**![SouthEast][]**

**try finally语句可以释放资源，不论是否发生异常。如：**

var in = new URL("http://ubmcmm.baidustatic.com/media/v1/0f0000g0bymVB3uhUffi-0.gif").openStream();
        
        try {
          process(in)
        }finally {
          in.close()
        }
        
        def process(in:java.io.InputStream) = {
          
          println(in.toString());
          
        }

输出：sun.net.www.protocol.http.HttpURLConnection$HttpInputStream@8b33e8

**   **

[SouthEast]: /images/20220823/6ed333c367f140e29af1d6984c054bfe.png