3.Scala-控制结构和函数

Myth丶恋晨 2024-04-20 09:05 70阅读 0赞

# 第3章 控制结构和函数 #

Java 中把表达式和语句当成两个不同的东西，表达式有值，语句没有值，

只是控制结构。在 Scala 中，几乎所有语法结构都有值。

## 3.1 If else 表达式 ##

scala> val x = 5
    x: Int = 5
    
    scala> val s = if( x > 0 ) 1 else -1
    s: Int = 1

S 为什么会有值？

If 语句的返回类型取决于最后一条语句。语句后面的分号不是必须的。

Scala 没有三元运算符，不需要。

![1604514-20190628232919429-1493732103.png][]

If 表达式会有一个返回值类型，如果 if 或者 else 返回的类型不一样，就

返回 Any 类型（所有类型的公共超类型）。

scala> val s1 = if( x > 0) "hello" else -1
    s1: Any = hello
    
    scala> val s3 = if ( x < 0 ) "hello"
    s3: Any = ()

如果缺少一个判断，什么都没有返回，但是 Scala 认为任何表达式都会

有值，对于空值，使用 Unit 类，写做（）【叫做无有用占位符，相当于 java

中的 void】

scala> val s4 = if(x < 0 ) "hello" else ()
    s4: Any = ()

注：行尾的位置不需要分号，只要能够从上下文判断出语句的终止即可。但是如果

在单行中写多个语句，则需要分号分割。在 Scala 中，\{\}快包含一系列表达

式，其结果也是一个表达式。块中最后一个表达式的值就是块的值。

## 3.2 while 表达式 ##

Scala 提供和 Java 一样的 while 和 do 循环，与 If 语句不同，While 语句

本身没有值，即整个 While 语句的结果是 Unit 类型的()。

while (n > 0) { 
        r = r * n
        n -= 1
        println(r)
    }
    do{
        r = r * n
        n -= 1
        println(r)
    }while(n > 0)

注：scala 并没有提供 break 和 continue 语句来退出循环，如果需要 break，可以

通过几种方法来做 1、使用 Boolean 型的控制变量 2、使用嵌套函数，从函数中

return 3、使用 Breaks 对象的 break 方法。

//循环的终止
    import scala.util.control.Breaks
    val looper = new Breaks() //括号可以省略
    
    var count = 0
    looper.breakable{         // . 可以替换成空格
      while(count <= 100){
        count += 1
        println(count)
        if(count == 10){
          looper.break()
        }
      }

//多重while循环的终止
    val whileLooper1 = new Breaks
    val whileLooper2 = new Breaks
    
    whileLooper1.breakable{
      while (true){
        count += 1
        if(count == 10){
          whileLooper1.break()
        }
        
        whileLooper2.breakable{
          while (true){
            if(count == 20){
              whileLooper2.break()
            }
          }
        }
        
      }
    }

## 3.3 for 表达式 ##

Scala 也为 for 循环这一常见的控制结构提供了非常多的特性，这些 for

循环的特性被称为 for 推导式（for comprehension）或 for 表达式（for

expression）。

推导式一词起源于函数式编程。

![1604514-20190629025914161-162455885.png][]

像 变量名 <- 集合 这样的表达式也被称为生成器表达式，该表达式会

基于集合生成单独的数值。

//多重for循环
    for(i <- 1 to 3; j <-1 to 3){
      println(i + "----" + j)
      println()
    }

//输出10 9 8 7 ... 1
    for(i <- Range(10, 0, -1)){
      println(i)
    }
    
    
    //输出1~9
    for(i <- 1 until 10){
      println(i)
    }

保护式，也叫守卫，可以添加一个或者多个守卫，不需要 continue 语句

![1604514-20190629025932602-1125908996.png][]

//实现1~10的输出，只输出偶数
    for (i <- 1 to 10 if i % 2 == 0){
      println(i)
    }

For 推导式可以引入变量

![1604514-20190629025955753-1746862720.png][]

//在for循环中添加变量表达式
    for(i <- 1 to 10; j = 10 - i; m = j * i){
      println("j:" + j)
      println("m:" + m)
    }

需要返回值怎么办？

使用 yield 关键字便能在 for 表达式中生成新的集合。for-yield 表达式所

生成的集合类型将根据被遍历的集合类型推导而出。

![1604514-20190629030024726-1364007284.png][]

scala> val forResult = for (i <- 1 to 10) yield i
    forResult: scala.collection.immutable.IndexedSeq[Int] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

尖叫提示：\{\}和()对于 for 表达式来说都可以。for 推导式有一个不成文的约定：当

for 推导式仅包含单一表达式时使用原括号，当其包含多个表达式时使用大括

号。值得注意的是，使用原括号时，早前版本的 Scala 要求表达式之间必须

使用分号。

![1604514-20190629030045338-1187116059.png][]

//使用花括号作为for循环的条件包裹
    for{
      i <- 1 to 3
      m = i * 2
    }
      println(m) //需要使用具体的逻辑

**Scala 随堂笔记**

一、变量的声明
        ** val：初始化后不能被再次赋值
        ** var：初始化之后可以多次复制
        ** if else：有返回值，如果多个逻辑控制代码块，返回不同的值，则返回为：Any
        ** 循环：
            ** while
                -- 返回值类型为Unit -> ()
                -- break的用法
            ** for
                -- 基本形式
                -- 守卫
                -- 表达式
                -- 多个循环体放在同一个参数体内
                -- 输出遍历元素到一个集合中并返回：yeild i
                -- {}花括号形式，用的不多

## 3.4 函数 ##

Scala 提供了很多函数，如果 math 函数，Java 中通常通过静态方法来模

拟。函数定义如下：

**def 函数名（参数名：类型…）\[: 返回类型\] = 函数体**

比如：

def play(a1 : Int, a2 : Int) : String = {
          
    　　　　　　(a1 + "," + a2)
    }
    
    　　　　def play(a1 : Int, a2 : Int) = { //返回值可以省略
    　　　　　　a1 + a2
    }
    
    　　　　def paly(a1 : Int, a2 : Int) = a1 + a2
    
    　　　　def paly = 1;

//标准形式
        def play1(a1: Int, a2: Int): String = {
          String.valueOf(a1 + a2)
        }
        println(play1(10, 20))
    
        //省略返回值形式（返回的是循环中最后一行的值）
        def play2(a1: Int, a2: Int) = {
          a1 + a2
        }
        println(play2(10, 10))
    
    
        //省略花括号形式
        def play3(a1: Int, a2: Int) = a1 + a2
        println(play3(5, 5))
    
    
        //返回Unit类型的函数
        def play4(a1: String) : Unit = {
          println(a1)
        }
    
    
        //返回Unit类型的函数，但是没有显示指定返回类型。（当然也可以返回非Unit类型的值）
        def play5(a1: String) = {
          println(a1)
        }
    
    
        //返回类型有多种可能，此时也可省略Unit
        def play6(a1: String) = {
          if(a1.length >= 3)
            a1 + "hello"
          else
            3
        }
    
    
        //可选参数
        def play7(a1: Int, a2: Int = 10) = {
          a1 + a2
        }
        println(play7(1))
    
    
        //变长参数
        def play8(args: Int*) = {
          for(i <- args){
            println(i)
          }
        }
        play8(1,2,3,4,5)
    
    
        //递归函数：在使用的时候必须要有明确的返回值类型
        //递归实现阶乘
        def factorial(n : Int) : Int = {
    
          if(n == 1)
            n
          else
            factorial(n - 1) * n
    
        }
        println(factorial(3))

注：1、Scala 可以通过=右边的表达式 推断出函数的返回类型。如果函数体需要

多个表达式，可以用代码块\{\}。

2、可以把 return 当做 函数版本的 break 语句。

3、递归函数一定要指定返回类型。

4、变长参数通过\* 来指定，所有参数会转化为一个 seq 序列

5、\_\* 告诉编译器 Range 当做参数序列化处理。

6、Head 是获得首元素，tail 是获取剩下元素的序列。

## 3.5 过程 ##

我们将不返回值得函数叫做过程，返回类型是 Unit，他是没有=号的。

1）定义过程示例1：（显示的返回值类型为Unit）

def shout1(content: String) : Unit = {
      println(content)  
    }

2）定义过程示例2：（隐式的返回值类型是Unit）

def shout1(content: String) = {
      println(content)  
    }

3）定义过程示例3：（没有 = 号）

def shout1(content: String) {
      println(content)  
    }

![1604514-20190629181120785-1077763172.png][]

## 3.6 匿名函数 ##

//匿名函数
        /*
          * 1、匿名函数右边的函数体应该使用 => 符号来指定
          * 2、匿名函数的函数体，可以是一个包含多行代码的代码块
          * 3、函数的类型，为参数个数的类型
         */
        val play10 = () => 0
        println(play10) //<function0> 表示传参个数为0
        println(play10()) //0
    
        val play11 = (a1 : Int) => 0
        println(play11) //<function1> 表示传参个数为1
    
        val play12 = (a1 : Int, a2 : Int) => {
          a1 + a2
          a2 - 10 + a1
        }
        println(play12) //<function2>
        println(play12(10, 20)) //20

## 3.7 懒值 ##

当 val 被声明为 lazy 时，他的初始化将被推迟，直到我们首次对此取

值。

懒值使用注意：

1) 用于初始化开销比较大的语句。

2) 可以解决循环依赖问题。

3) 是开发懒数据结构的基础。

1）lazy 示例：通过 lazy 关键字的使用与否，来观察执行过程

def play1(a1: Int) = {
          println("play1方法被执行," + "a1:" + a1)
          a1
        }
    
        lazy val l1 = play1(10)
        val l2 = play1(20)
        println("l1变量定义完毕")
        println(l1)
    
        /*
        结果：
        play1方法被执行,a1:20
        lazy变量定义完毕
        play1方法被执行,a1:10
        10
         */

## 3.8 异常 ##

当碰到异常情况时，方法抛出一个异常，终止方法本身的执行，异常传

递到其调用者，调用者可以处理该异常，也可以升级到它的调用者。运行系

统会一直这样升级异常，直到有调用者能处理它。 如果一直没有处理，则终

止整个程序。

Scala 的异常的工作机制和 Java 一样，但是 Scala 没有“受检”异常，你

不需要声明说函数或者方法可能会抛出某种异常。受检异常在编译器被检

查，java 必须声明方法所会抛出的异常类型。

抛出异常：用 throw 关键字，抛出一个异常对象。所有异常都是

Throwable 的子类型。throw 表达式是有类型的，就是 Nothing，因为 Nothing

是所有类型的子类型，所以 throw 表达式可以用在需要类型的地方。

／／并不像 Java 代码那样，需要声明方法会抛出异常，这给程序员省去理论很多烦恼。
    def divide(x: Int, y: Int): Int = {
        if (y == 0) throw new Exception("Divide by zero")
        else x / y
    }

捕捉异常：

在 Scala 里，借用了模式匹配的思想来做异常的匹配，因此，在 catch 的

代码里，是一系列 case 字句。

异常捕捉的机制与其他语言中一样，如果有异常发生，catch 字句是按次

序捕捉的。因此，在 catch 字句中，越具体的异常越要靠前，越普遍的异常越

靠后。 如果抛出的异常不在 catch 字句中，该异常则无法处理，会被升级到

调用者处。

异常捕获通常采用模式匹配的语法：

try { 
     process(in)
    } catch { 
     case ex: IOException => println(ex)
    } finally { 
     in.close()}

finally 字句用于执行不管是正常处理还是有异常发生时都需要执行的步

骤，一般用于对象的清理工作。

注：1、Throw 的类型为 Nothing，存在 exception 的 if 语句类型返回类型。

object ExceptionSyllabus {
    
      def divider(x: Int, y: Int): Float = {
    
        if(y == 0) throw new Exception("0 不能作为除数")
        else x/y
    
      }
    
      def main(args: Array[String]): Unit = {
    
        try {
          println(divider(10, 0))
        } catch {
          case ex:Exception => println("成功捕获异常" + ex.getMessage)
    //      case ex:Throwable => println("成功捕获异常" + ex.getMessage)
        } finally {}
    
      }
    
    }

转载于:https://www.cnblogs.com/LXL616/p/11105476.html

[1604514-20190628232919429-1493732103.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/ddebc94029d7436981eab1ce2b1053a1.png
[1604514-20190629025914161-162455885.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/4157d63a42a74f31921200b7e5de28ec.png
[1604514-20190629025932602-1125908996.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/1aca1f7a0e0f45be8ca10975970d5101.png
[1604514-20190629025955753-1746862720.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/762dad7889c44525b5cab511bd36b5a6.png
[1604514-20190629030024726-1364007284.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/514c11a7d5744582bbe93c384697e543.png
[1604514-20190629030045338-1187116059.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/5bb5c39e76a44b8b812fa1c284463682.png
[1604514-20190629181120785-1077763172.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/3dc99bc08ec941eb9062a1b4c2af5792.png