IV.控制结构

1.if/else

除基本用法外，if/else语句能用来赋值，进而代替?:运算符。这得益于在Scala中，每个语句块都有值，就是该语句块最后一个语句的值。请看下面的代码。

def abs(x: Int) = if(x < 0) -x else x

2.与If语句不同，While语句本身没有值，即整个While语句的结果是Unit类型的()。

 PS：scala中赋值语句也没有值。

3.用于迭代一个集合的for语句，格式为for(item <- collection)。一些collection举例：

0 to list.length - 1
0 until list.length
val list = List("Tom", "Jach", "Jimmy", "Abby")

  • 嵌套for循环  直接分号隔开就行。
for(i <- 0 to 1; j <- 1 to 2; k <- 2 to 3) {
    println("i = %d, j = %d, k = %d".format(i, j, k))
  }
  • 条件for循环 例如下面代码，i带有条件 i % 2 == 0，这意味着，仅有满足这个条件的i才会被循环执行。
for{i <- 0 to 5 
    if i % 2 == 0 
    j <- 1 to 2} {
  println("i = %d, j = %d".format(i, j))
}
  • 中途绑定变量
／／引入了变量lower，这与通常我们定义变量的方式相比，只是少了val。这个变量在for表达式中和循环体中都可以使用。
val list = List("Html", "XML", "JSON", "text", "md")
for{ ext <- list 
    lower = ext.toLowerCase 
    if lower != "html"} {
  println("Accepted data format: " + lower)
}

产生新的集合　　 for(claus) yield {body} 可以用来产生新的集合。

val result =
  for(i <- 1 to 3; j <- 2 to 4)
  yield {
    i + j
  }
println(result)

4.match

"your selector" match {
  case "case 1" => //handle case 1     
  case "case 2" => //handle case 2
  ...
  case _ => //handle the rest, like default in switch-case
}
  • 任意类型的常量或结果为常量的表达式都可以用于match语句。
  • 每个分支不需要以break结束，因为Scala里没有贯穿执行（fall through）。
  • 与if表达式一样，match表达式也有结果。这也是可以理解的，match其实是多个分支的if的另一种写法。
def passed_?(grade: Char) = {
  grade match {
    case 'A' | 'B' | 'C' => true    ／／case 'A' | 'B' | 'C' => true这正是其他语言中，switch-case贯穿执行的情况
    case _ => false
  }
}

5.异常

当碰到异常情况时，方法抛出一个异常，终止方法本身的执行，异常传递到其调用者，调用者可以处理该异常，也可以升级到它的调用者。运行系统会一直这样升级异常，直到有调用者能处理它。 如果一直没有处理，则终止整个程序。

  • 抛出异常：用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字句中，该异常则无法处理，会被升级到调用者处。 

finally字句用于执行不管是正常处理还是有异常发生时都需要执行的步骤，一般用于对象的清理工作。

6.中断循环：  

  • Scala中没有break或continue关键字。可以使用Breaks类的break方法，来实现退出循环的功能。breakException是一个ControlThrowable类型的异常。此外，你的循环代码还需要用breakable包围起来，breakable的作用是捕获break抛出的异常，以免影响你真正的产品代码。 
    import scala.util.control.Breaks._
  • 函数式编程的思想，尽量避免使用break。函数式编程几乎离不开递归。 更特别的，以下hasHtml是一个尾递归，大部分函数式语言编译器都对尾递归有优化，Scala也不例外。对程序员来说，不用担心使用尾递归会带来性能下降。
val list = List("functions.md", "menu.json", "index.html", "data.xml")

def hasHtml(input: List[String]): Boolean = {
  input match {
    case Nil => false
    case x :: sub => {
      if(x.endsWith("html")) return true
      else hasHtml(sub)
    }
  }
}

if(hasHtml(list)) println("There is at least one html file in the list")
else println("There is no html file in the list")

 

V.类和对象

1.默认的访问修饰符是public。

Scala的类都有默认的基本构造函数，可以使用new来创建对象。 

  • 在类定义中，所有不属于方法和字段的语句，都属于主构造函数。

  • 基本构造函数的参数就是类参数，类参数（或默认构造函数参数）默认的访问级别是对象私有，即private[this] val，若想要在类外部也能使用，只需显示注明为val或var，比如class ScoreCalculator(val athlete: String)。

  • 私有构造函数  private放在类参数列表前 
    class ScoreCalculator private(val athlete: String) 
class ScoreCalculator(athlete: String) {
  private var total, count = 0
  
  println("This is in the primary constructor")
  
  def report(score: Int) {
    total += score
    count += 1
  }
  
  def score = if (count == 0) 0 else total / count 
  
  override def toString() = athlete + "'s score is " + score
}

val sc = new ScoreCalculator("Yao")
println("\nJust created an object, now you can use it.\n")
sc.report(80)
sc.report(90)
println(sc)
  • 辅助构造函数 ：构造函数用this标识。必须先调用主构造函数，或者在它之前定义的其他构造函数。这意味着，主构造函数是唯一创建对象的途径，不论你调用的是哪个构造函数。
class ScoreCalculator {
  var athlete = ""
  var degreeOfDifficulty = 0.0
  
  def this(athlete: String) {
    this()       //Call primary constructor
    this.athlete = athlete
  }
  
  def this(athlete: String, degreeOfDifficulty: Double) {
    this(athlete)   //Call another auxiliary constructor
    this.degreeOfDifficulty = degreeOfDifficulty
  }
  
  override def toString = "Athlete: " + athlete + ", degree of difficulty: " + degreeOfDifficulty
}

val sc1 = new ScoreCalculator("Gao Min")
sc1.degreeOfDifficulty = 3.7
println(sc1)

val sc2 = new ScoreCalculator("Fu Mingxia", 3.5)
println(sc2)

2.类的属性

  • scala的getter方法格式如name_= (parameters)，名称，下划线和等号是一个整体，之间不能有空格。
  • setter方法必须与getter成对出现，也就是不能只写不读。相反，getter可以单独出现，也就是说只读是可能的。
  • 没有声明为private的字段自动生成getter,setter方法。

不是很懂，再研究吧。

3.单例对象：消除静态。单例对象可分为两种，不与某个类共享源文件和名称的，称为独立对象（Standalone Object），与此相反，与某个类共享名称的，称为伴生对象（Companion Object）。

  • 独立对象类似于静态类，在一个运行环境中，只会有唯一一个这个类型的对象，它是单例设计模式的天然实现，在第一次被使用的时候由运行环境将它实例化。其定义方式与类相似，只是将关键字换成object。 其他的方面也跟类相似，比如可以继承其他类和特质。只是有一个区别，不能有类参数，也就是构造函数参数。
  • 如果一个单例对象跟类有相同的名字，而且它们在同一个源文件里，那么就称之为这个类的伴生对象。它和伴生类能互相访问对方的私有成员。
  • apply方法是对象的一类特有方法，一般可用于创建伴生类。apply方法可以用简洁的方式调用，形如Object(args..)。

4.独立对象可以包含main方法，并且可以用extends App表示（app特质）。

object MyApplication extends App {
  args.foreach(println)
}