Scala 學習記錄（一）

1. 相對於java，scala的值修飾用val，變數修飾用var.值相當於java的final 修飾了。

package demo

object ScalaBase extends App {
  println(1)
  println(1 + 1)
  println("Hello！")
  println("Hello," + " World!")
  /**
    * val 是值得修飾符，相當於java的final int x;
    * scala 可以不指名類型
    */
  val x = 1 + 1
  println(x)
  ///x =2 //不編譯的
 //指明類型可以如下寫
  val x1 : Int = 1 + 1
  println(x1)

  /**
    * var 是變數修飾符，相當於java int x2,不加final修飾
    */
  var x2 = 1 + 1
  x2 = 3
  println(x2 * x2)

  /**
    * scala 是個萬能表達式語言,比如可以通過{}組合表達式
    */
  println({
    val x = 1 + 1
    x + 1
  })
  println({
    val x = "test " + "scala "
    x + "demo!"
  })

  /**
    * scala相對於java 方法定義，分為函數和方法
    * 函數是帶參數的表達式,也就是相對於java8的匿名方法（）->{}
    * (int x, int y) ->{}
    * 左邊是參數，右邊是表達式
    */
  (x: Int) => x + 1
  val addOne = (x: Int) => x + 1
  println(addOne(1))

  val add = (x: Int,y: Int) => x + y
  println(add(1,2))
  val getTheAnswer = () => 42
  println(getTheAnswer())

  /**
    * def 是方法關鍵字
    * def 後面是方法名
    * 與java不同的是，scala的返回類型是寫在: Int
    * =後面就是方法體
    * 類似於java的 public int addMethod(int x, int y) {return x + y}
    * 註意：scala雖然有return保留字，一般都不用，scala用最後一行進行返回
    * @param x
    * @param y
    * @return
    */
  def addMethod (x: Int, y: Int): Int = x + y
  println(addMethod(1, 2))
  /**
    * 方法可以有多個參數
    * 相對於java，scala有多個參數類別，不用定義在同一（）裡面，比較明顯表明表達式結構
    */
  def addThenMultiply(x: Int, y: Int)(multiplier: Int): Int = {
    (x + y) * multiplier
  }

  /**
    * 當然scala也可以沒有參數
    */
  def name: String = System.getProperty("name")
  println("Hello, " + name + "!")
  /**
    * scala 可以用{}使用多行表達式
    */
  def getSquareString(input: Double): String = {
    val square = input * input
    square.toString
  }

  println(getSquareString(2.22))

  /**
    * 類跟Java一樣都是用class 關鍵字
    * 不同的是scala的參數可以定義在（）裡面
    * 類似於Java的構造函數
    * 相對於java用void表示沒有返回值，scala用 Unit
    */
  class Greeter(prefix: String, suffix: String) {
    def greet(name: String): Unit = println(prefix + name + suffix)
  }

  /**
    * scala 同樣使用new 作為創建實例的關鍵字
    */
  val greeter = new Greeter("Hello,","!")
  greeter.greet("Scala developer")

  /**
    * case class 是一個非常特殊的類，它可以用於模式匹配
    * case class 可以不用new關鍵字
    * 它是一個public類
    * 它自動生成hashCode 、equals
    */
  case class Point(x: Int,y: Int)
  val point = Point(1, 2)
  val anotherPoint = Point(1, 2)
  val yetAnotherPoint = Point(2, 2)
  if (point == anotherPoint) {
    println(point + " and " + anotherPoint + " are the same.")
  } else {
    println(point + " and " + anotherPoint + " are different.")
  }
  // Point(1,2) and Point(1,2) are the same.

  if (point == yetAnotherPoint) {
    println(point + " and " + yetAnotherPoint + " are the same.")
  } else {
    println(point + " and " + yetAnotherPoint + " are different.")
  }

  /**
    * Objects 是一個單例，不能用new
    * 就像Java定義單例模式一樣，它只有一個
    */
  object IdFactory {
    private var counter = 0
    def create(): Int = {
      counter += 1
      counter
    }
  }

  val newId: Int = IdFactory.create()
  println(newId)
  val newerId: Int = IdFactory.create()
  println(newerId)

  /**
    * Traits 類似於Java的Interface，只不過Traits可以部分實現
    * Java 只能通過default 進行部分實現，實現包內訪問
    * trait 只用extends修飾，到不用實現
    */
  trait GreeterTrait {
    def greet(name: String): Unit
    def greetDefault(name: String): Unit =
      println("Hello, " + name + "!")
  }

  class DefaultGreeterTrait extends GreeterTrait {
    override def greet(name: String): Unit = {
      println()
    }
  }

  class CustomizableGreeter(prefix: String, postfix: String) extends GreeterTrait {
    override def greet(name: String): Unit = {
      println(prefix + name + postfix)
    }
  }

  val greeterTrait = new DefaultGreeterTrait()
  greeterTrait.greet("Scala developer")
  val customizableGreeter = new CustomizableGreeter("How are you","?")
  customizableGreeter.greet("Scala developer")

  /**
    * scala 是運行與jvm，因此也需要一個主要方法main,main也是一個字元串數組
    */
}

object ScalaMain {
  def main(args: Array[String]): Unit =
    println("Hello, Scala developer!")
}