scala 基礎文法__scala

運算式

scala> 1 + 1res0: Int = 2

  值

你可以給一個運算式的結果起個名字賦成一個不變數（val）。

scala> val two = 1 + 1two: Int = 2

  變數

如果你需要修改這個名稱和結果的綁定，可以選擇使用var。

scala> var name = "steve"name: java.lang.String = stevescala> name = "marius"name: java.lang.String = marius

  函數

你可以使用def建立函數.

scala> def addOne(m: Int): Int = m + 1addOne: (m: Int)Int

 

在Scala中，你需要為函數參數指定類型簽名。

scala> val three = addOne(2)three: Int = 3

 

如果函數不帶參數，你可以不寫括弧。

scala> def three() = 1 + 2three: ()Intscala> three()res2: Int = 3scala> threeres3: Int = 3

  匿名函數

你可以建立匿名函數。

scala> (x: Int) => x + 1res2: (Int) => Int = <function1>

 

這個函數為名為x的Int變數加1。

scala> res2(1)res3: Int = 2

 

你可以傳遞匿名函數，或將其儲存成不變數。

scala> val addOne = (x: Int) => x + 1addOne: (Int) => Int = <function1>scala> addOne(1)res4: Int = 2

 

如果你的函數有很多運算式，可以使用{}來格式化代碼，使之易讀。

def timesTwo(i: Int): Int = {  println("hello world")  i * 2}

 

對匿名函數也是這樣的。

scala> { i: Int =>  println("hello world")  i * 2}res0: (Int) => Int = <function1>

 

在將一個匿名函數作為參數進行傳遞時，這個文法會經常被用到。 部分應用（Partial application）

你可以使用底線“_”部分應用一個函數，結果將得到另一個函數。Scala使用底線表示不同上下文中的不同事物，你通常可以把它看作是一個沒有命名的神奇萬用字元。在{ _ + 2 }的上下文中，它代表一個匿名參數。你可以這樣使用它：

scala> def adder(m: Int, n: Int) = m + nadder: (m: Int,n: Int)Intscala> val add2 = adder(2, _:Int)add2: (Int) => Int = <function1>scala> add2(3)res50: Int = 5

 

你可以部分應用參數列表中的任意參數，而不僅僅是最後一個。 柯裡化函數

有時會有這樣的需求：允許別人一會在你的函數上應用一些參數，然後又應用另外的一些參數。

例如一個乘法函數，在一個情境需要選擇乘數，而另一個情境需要選擇被乘數。

scala> def multiply(m: Int)(n: Int): Int = m * nmultiply: (m: Int)(n: Int)Int

 

你可以直接傳入兩個參數。

scala> multiply(2)(3)res0: Int = 6

 

你可以填上第一個參數並且部分應用第二個參數。

scala> val timesTwo = multiply(2) _timesTwo: (Int) => Int = <function1>scala> timesTwo(3)res1: Int = 6

 

你可以對任何多參數函數執行柯裡化。例如之前的adder函數

第一次傳參是一個加數，返回一個函數，調用第二個函數傳參，另一個數，得出結果是和

scala> (adder _).curriedres1: (Int) => (Int) => Int = <function1>scala> res1(2)res2: (Int) => Int = <function1>scala> res2(3)res3: Int = 5

  可變長度參數

這是一個特殊的文法，可以向方法傳入任意多個同類型的參數。例如要在多個字串上執行String的capitalize函數，可以這樣寫：

def capitalizeAll(args: String*) = {  args.map { arg =>    arg.capitalize  }}scala> capitalizeAll("rarity", "applejack")res2: Seq[String] = ArrayBuffer(Rarity, Applejack)

  類

scala> class Calculator {     |   val brand: String = "HP"     |   def add(m: Int, n: Int): Int = m + n     | }defined class Calculatorscala> val calc = new Calculatorcalc: Calculator = Calculator@e75a11scala> calc.add(1, 2)res1: Int = 3scala> calc.brandres2: String = "HP"

 

上面的例子展示了如何在類中用def定義方法和用val定義欄位值。方法就是可以訪問類的狀態的函數。 建構函式

建構函式不是特殊的方法，他們是除了類的方法定義之外的代碼。讓我們擴充計算機的例子，增加一個建構函式參數，並用它來初始化內部狀態。

class Calculator(brand: String) {  /**   * A constructor.   */  val color: String = if (brand == "TI") {    "blue"  } else if (brand == "HP") {    "black"  } else {    "white"  }  // An instance method.  def add(m: Int, n: Int): Int = m + n}

 

注意兩種不同風格的評論。

你可以使用建構函式來構造一個執行個體：

scala> val calc = new Calculator("HP")calc: Calculator = Calculator@1e64cc4dscala> calc.colorres0: String = black

  運算式

上文的Calculator例子說明了Scala是如何面向運算式的。顏色的值就是綁定在一個if/else運算式上的。Scala是高度面向運算式的：大多數東西都是運算式而非指令。 旁白: 函數 vs 方法

函數和方法在很大程度上是可以互換的。由於函數和方法是如此的相似，你可能都不知道你調用的東西是一個函數還是一個方法。而當真正碰到的方法和函數之間的差異的時候，你可能會感到困惑。

scala> class C {     |   var acc = 0     |   def minc = { acc += 1 }     |   val finc = { () => acc += 1 }     | }defined class Cscala> val c = new Cc: C = C@1af1bd6scala> c.minc // calls c.minc()scala> c.finc // returns the function as a value:res2: () => Unit = <function0>

 

當你可以調用一個不帶括弧的“函數”，但是對另一個卻必須加上括弧的時候，你可能會想哎呀，我還以為自己知道Scala是怎麼工作的呢。也許他們有時需要括弧。你可能以為自己用的是函數，但實際使用的是方法。

在實踐中，即使不理解方法和函數上的區別，你也可以用Scala做偉大的事情。如果你是Scala新手，而且在讀兩者的差異解釋，你可能會跟不上。不過這並不意味著你在使用Scala上有麻煩。它只是意味著函數和方法之間的差異是很微妙的，只有深入語言內部才能清楚理解它。 繼承

class ScientificCalculator(brand: String) extends Calculator(brand) {  def log(m: Double, base: Double) = math.log(m) / math.log(base)}

 

參考 Effective Scala 指出如果子類與父類實際上沒有區別，類型別名是優於繼承的。A Tour of Scala 詳細介紹了子類化。 重載方法

class EvenMoreScientificCalculator(brand: String) extends ScientificCalculator(brand) {  def log(m: Int): Double = log(m, math.exp(1))}

  抽象類別

你可以定義一個抽象類別，它定義了一些方法但沒有實現它們。取而代之是由擴充抽象類別的子類定義這些方法。你不能建立抽象類別的執行個體。

scala> abstract class Shape {     |   def getArea():Int    // subclass should define this     | }defined class Shapescala> class Circle(r: Int) extends Shape {     |   def getArea():Int = { r * r * 3 }     | }defined class Circlescala> val s = new Shape<console>:8: error: class Shape is abstract; cannot be instantiated       val s = new Shape               ^scala> val c = new Circle(2)c: Circle = Circle@65c0035b

  特質（Traits）

特質是一些欄位和行為的集合，可以擴充或混入（mixin）你的類中。

trait Car {  val brand: String}trait Shiny {  val shineRefraction: Int}class BMW extends Car {  val brand = "BMW"}

 

通過with關鍵字，一個類可以擴充多個特質：

class BMW extends Car with Shiny {  val brand = "BMW"  val shineRefraction = 12}

 

參考 Effective Scala 對特質的觀點。

什麼時候應該使用特質而不是抽象類別。 如果你想定義一個類似介面的類型，你可能會在特質和抽象類別之間難以取捨。這兩種形式都可以讓你定義一個類型的一些行為，並要求繼承者定義一些其他行為。一些經驗法則： 優先使用特質。一個類擴充多個特質是很方便的，但卻只能擴充一個抽象類別。
如果你需要建構函式參數，使用抽象類別。因為抽象類別可以定義帶參數的建構函式，而特質不行。例如，你不能說trait t(i: Int) {}，參數i是非法的。

你不是問這個問題的第一人。可以查看更全面的答案： stackoverflow: Scala特質 vs 抽象類別 , 抽象類別和特質的區別, and Scala編程: 用特質，還是不用特質。 類型

此前，我們定義了一個函數的參數為Int，表示輸入是一個數字類型。其實函數也可以是泛型的，來適用於所有類型。當這種情況發生時，你會看到用方括弧文法引入的型別參數。下面的例子展示了一個使用泛型鍵和值的緩衝。

trait Cache[K, V] {  def get(key: K): V  def put(key: K, value: V)  def delete(key: K)}

 

方法也可以引入型別參數。

def remove[K](key: K)

 

=======================================================================================================================================================================

apply 方法

當類或對象有一個主要用途的時候，apply方法為你提供了一個很好的文法糖。

scala> class Foo {}defined class Fooscala> object FooMaker {     |   def apply() = new Foo     | }defined module FooMakerscala> val newFoo = FooMaker()newFoo: Foo = Foo@5b83f762

 

或

scala> class Bar {     |   def apply() = 0     | }defined class Barscala> val bar = new Barbar: Bar = Bar@47711479scala> bar()res8: Int = 0

 

在這裡，我們執行個體化對象看起來像是在調用一個方法。以後會有更多介紹。 單例對象

單例對象用於持有一個類的唯一執行個體。通常用於原廠模式。

object Timer {  var count = 0  def currentCount(): Long = {    count += 1    count  }}

 

可以這樣使用：

scala> Timer.currentCount()res0: Long = 1

 

單例對象可以和類具有相同的名稱，此時該對象也被稱為“伴生對象”。我們通常將伴生對象作為工廠使用。

下面是一個簡單的例子，可以不需要使用’new’來建立一個執行個體了。Apply

class Bar(foo: String)object Bar {  def apply(foo: String) = new Bar(foo)}

  函數即對象

在Scala中，我們經常談論對象的函數式編程。這是什麼意思。到底什麼是函數呢。

函數是一些特質的集合。具體來說，具有一個參數的函數是Function1特質的一個執行個體。這個特徵定義了apply()文法糖，讓你調用一個對象時就像你在調用一個函數。

scala> object addOne extends Function1[Int, Int] {     |   def apply(m: Int): Int = m + 1     | }defined module addOnescala> addOne(1)res2: Int = 2

 

這個Function特質集合下標從0開始一直到22。為什麼是22。這是一個主觀的魔幻數字(magic number)。我從來沒有使用過多於22個參數的函數，所以這個數字似乎是合理的。

apply文法糖有助於統一對象和函數式編程的二重性。你可以傳遞類，並把它們當做函數使用，而函數本質上是類的執行個體。

這是否意味著，當你在類中定義一個方法時，得到的實際上是一個Function*的執行個體。不是的，在類中定義的方法是方法而不是函數。在repl中獨立定義的方法是Function*的執行個體。

類也可以擴充Function，這些類的執行個體可以使用()調用。

scala> class AddOne extends Function1[Int, Int] {     |   def apply(m: Int): Int = m + 1     | }defined class AddOnescala> val plusOne = new AddOne()plusOne: AddOne = <function1>scala> plusOne(1)res0: Int = 2

 

可以使用更直觀快捷的extends (Int => Int)代替extends Function1[Int, Int]

class AddOne extends (Int => Int) {  def apply(m: Int): Int = m + 1}

  包

你可以將程式碼群組織在包裡。

package com.twitter.example

 

在檔案頭部定義包，會將檔案中所有的代碼聲明在那個包中。

值和函數不能在類或單例對象之外定義。單例對象是組織靜態函數(static function)的有效工具。

package com.twitter.exampleobject colorHolder {  val BLUE = "Blue"  val RED = "Red"}

 

現在你可以直接存取這些成員

println("the color is: " + com.twitter.example.colorHolder.BLUE)

 

注意在你定義這個對象時Scala解譯器的返回：

scala> object colorHolder {     |   val Blue = "Blue"     |   val Red = "Red"     | }defined module colorHolder

 

這暗示了Scala的設計者是把對象作為Scala的模組系統的一部分進行設計的。 模式比對

這是Scala中最有用的部分之一。

匹配值

val times = 1times match {  case 1 => "one"  case 2 =>