1、變數

Scala和Java一樣，有7種數值型別Byte、Char、Short、Int、Long、Float和Double（無包裝型別）和一個Boolean型別

/**
  *  宣告、定義變數
  */

object VariableDemo {
  def main(args: Array[String]): Unit = {
    // 定義一個變數，吧變數名在前，型別在後。
    var i: Int = 100;

    //Scala編譯器會自動推斷變數的型別，必要的時候可以指定型別。
    var i2 = 100
    var s: String = "Hello Scala"
    var s2 = "Hello World"

    // 使用val修飾的變數不可變，相當於java裡用final修飾的變數，scala中推薦使用val。
    val s3 = "使用val修飾的變數不可變"

  }
 

/**
  * 條件表示式
  */
object ConditionExprDemo {
  def main(args: Array[String]): Unit = {
    val a = 100
    val b = 200
    // 比較a、b的大小，獲取較大的值，但不建議用這種方式
    var max = 0
    if (a > b) {
      max = a
    } else {
      max = b
    }

    // scala中可以直接將使用如下語法，推薦使用。
    var max2 = if (a > b) a else b
    println(max + "," + max2)

    // 同時支援塊表示式
    val c = 300
    var max3 = if (a > b){
      if (a > c) a else c
    } else {
      if (b > c) b else c
    }
    println(max3)
  }
}
 

/**
  * 迴圈
  */
object LoopDemo {
  def main(args: Array[String]): Unit = {
    // for (i <- 表示式/陣列/集合)
    // 1 to 10 相等於Int.to(Int)，在一個匿名空間構造值為1的Int變數，呼叫to(Inf)方法
    for (i <- 0 to 10) println(i)  // 左閉右閉
    for (i <- 0 until 10) println(i) // 左閉右開區間
    for (i <- Range(0,10)) println(i) // 左閉右開區間

    // 雙重迴圈，迴圈構造器中還能加上條件表示式，yield是關鍵字，可以把再構造一個新的陣列
    var arr = for (i <- 1 to 9; j <- 1 to 9 if i == j ) yield i + j
    println(arr.toBuffer)
  }
}
 

object FunctionAndMethodDemo {

  // 定義一個函式
  val add : (Int, Int) => Int = {
    (x, y) => x + y
  }

  // 同樣是定義一個函式
  val dif = (x: Int, y: Int) => (x - y)

  // 定義一個方法
  def  mult(x: Int, y: Int) : Int = {
    x * y
  }

  // 定義一個方法
  def Calculate(func:(Int, Int) => Int, x: Int, y: Int) : Int = {
    func(x,y)
  }

  val Calculate2 =  (func:(Int, Int) => Int, x: Int, y: Int) => {
    func(x,y).toString
  }


  def main(args: Array[String]): Unit = {
    println(Calculate(add,3,2))
    println(Calculate(mult,3,2))
    println(Calculate2(dif,1,2))
    println(Calculate2(mult,6,2))

    // 呼叫函式，傳入匿名函式
    println(Calculate2((x,y) => x / y, 10,5))
    // 呼叫方法，傳入匿名函式
    println(Calculate2((x,y) => {println("hello world.");x / y}, 10,2))

    // 將一個方法強轉為函式型別
    val f = mult _
  }

}