http://twitter.github.io/scala_school/zh_cn/basics.html

• （有名）函數

相對于下面的匿名函數而言。它有名字。

def addOne(x: Int): Int = x + 1

一目了然，這個函數名字為addOne，接受一個x整形參數，函數的輸出為Int，實現的動作是+1。

• 匿名函數

(x: Int) => x + 1

從什么到什么，即為函數。和數學里的一樣，表達一種映射關系，比如從x->y，從自變量到因變量的對應關系。

Scala支持匿名函數，表達形式和數學式高度一致，(input: Type) => output

那么匿名函數是沒有名字的，每次使用難道都要寫完整的函數？不是。

匿名函數沒有名字，但依舊可以給它一個變量名。即：

val addOneVal = (x: Int) => x + 1

這樣一來，雖然右邊的函數依舊沒有函數名，如上面的有名函數那樣，但還是可以方便的使用它。

更進一步說，如果匿名函數內容比較多。
(x:Int) =>
println(x)
x+1
這種形式編譯無法通過，需要格式化一下代碼。
(x:Int) => {
println(x)
x+1
}
或者
{(x:Int) =>
println(x)
x+1
}
所以對于復雜點的匿名函數，下面的就是方便的形式
val addOneValNice = {(x:Int) =>
println(x)
x+1
}

• 部分應用(Partial application)

假設我們有一個函數
def addTwo(a: Int, b: Int) :Int = a + b
這個函數有兩個參數，a和b?，F在我們的需求變了，我們希望將a的值固定下來，比如a=2.我們可以定義一個新的函數，只接受一個參數。
def addA(b: Int): Int = 2 + b
這樣當然是可以的。但能不能利用現有的addTwo這個函數，直接生成一個呢？這個需求就是部分應用的存在意義。因為不需要重新定義個函數了，所以我們就不用def了，否則就是如上的形式。這里我們使用匿名函數。

scala> val addANicely = addTwo(2, _: Int)
addANicely: Int => Int = $$Lambda$1179/1218188770@923bf67

那這個方式，能不能直接用在匿名函數本身呢？比如我們有

scala> val addTwoAB = (a: Int, b: Int) => a + b
addTwoAB: (Int, Int) => Int = $$Lambda$1190/137646750@5c519da4

可不可以直接使用部分應用？答案是可以的。

scala> val addANicelyAnomy = addTwoAB(2, _:Int)
addANicelyAnomy: Int => Int = $$Lambda$1199/742878095@2e5affb3

• 柯里化函數
  首先，什么是柯里化？
  簡單來說，當一個函數需要多個參數時，我們一般把這種需要理解為同時需要。比如，計算舉行面積，我們需要長和寬，當這兩個條件都具備時，我們才可以計算出面積。下面這個三個數相乘的函數也可以這么理解。
  def area(w: Int, l: Int) = w * l
  但我們能不能有時候換個角度理解，把這種同時需要的并行關系，理解為一種逐個需要的線性關系。也就是說，當有a之后，我們需要b，然后我們需要c，最后我們可以算出結果。
  這么做的理由和需求是什么？想象一下矩形面積問題，原本的需求是：
  • 計算一個矩形的面積，需要處理的矩形w和l都是未知的；
    但如果需求變了，
  • 計算一個矩形的面積，它們的w是已知的；
    我們會很自然的想到利用部分應用，也就是

val areaWithW = area(3, _: Int)

這個想法很自然，但這里有一個隱含假設，即我們不僅知道w是已知的，而且我們現在就知道了。但如果我們將來才知道呢？或者這個已知的w本身并不是一個固定的值，而是若干值，那我們是不是每次只有在這些值已知的時候，才能定義出如上面這樣的函數，而不能提前定義出來？
這個需求確實有點具體，所以其實更容易理解的，還是并行和線性的比方。
柯里化之后的函數，原本并行著的參數，會形成一串線性的參數，每當一個確定了一個參數，剩下的部分依舊是個柯里化的函數，直到只剩一個參數為止，到此函數變成一個單一參數的函數。用下面的三個數乘法舉例。

scala> def multiplyThree(a: Int, b: Int, c: Int) = a * b * c
multiplyThree: (a: Int, b: Int, c: Int)Int
scala> (multiplyThree _).curried //柯里化
res29: Int => (Int => (Int => Int)) = scala.Function3$$Lambda$1270/809597275@4d1847de
multiplyThree(2) // 即確定了a

從函數的形態，我們可以看清楚這種變化的關系，柯里化之后的函數是

Int => (Int => (Int => Int))

如果回到數學式子

area = f(a,b,c) = a * b * c
f: (a, b, c) -> area
k: a -> (b -> (c -> area))

所以，柯里化是一種函數對應關系的變化。而具體的某一個柯里化的結果比如
area(1)(2)
則可以看作是一種部分應用了，即

area(1, 2, _: Int)。

• 可變長度參數

含義很明確，如果一個方法有多個參數，且并不知道具體有多少個，可以采用如下的形式。

def capitalizeAll(args: String*) = {
  args.map { arg =>
    arg.capitalize
  }
}

scala> capitalizeAll("rarity", "applejack")
res2: Seq[String] = ArrayBuffer(Rarity, Applejack)

• 構造函數

構造函數在scala和在Java看起來很不同。在Java中，是如下的形式：

public class Calculator{
    public String brand;
    public Calculator(String brand){ //構造器
        this.brand = brand;
    }

    public static void main(String[] args){

        Calculator s = new Calculator("bd");
        System.out.println(s.brand);
    }
}

構造函數很明確的指定了參數。當然，不同的參數組成，就需要不同的構造器。
Scala的則不同，更簡潔，但可能也會造成更不習慣，如果你習慣了java的。

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的構造器，實際上就是類名稱旁邊的那部分參數列表了，因為不再需要單獨的一個method。不過這樣帶來了一個問題，java的構造器和參數，不一定是public的。而scala的做法是將參數放在類名稱旁邊，并自動生成一個public構造方法以及val的字段。
所以說，scala的上述寫法=public constructor + public val field。

這部分值得單獨開一篇來寫了。比如http://joelabrahamsson.com/learning-scala-part-four-classes-and-constructors/。

• 繼承
  如下所示即為繼承。但需要注意的是，Scala有一個很好的工具，type alias，類型別名。

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

類型別名的意思，就是可以給類型命名，也就是自定義一個(復雜)類型，比如如下的情況。

type Row = List[Int] //給List[Int]起名字為Row，很好的解釋了數學中的行的概念
type Matrix = List[Row] //給行的列表起名為Matrix，很直觀

可以發現，用type alias起名字，可以更直觀的表達比較復雜的類型。
除此之外，還可以用如下的形式來使用類型別名。這樣的好處是，如果你要繼承的東西并沒有改變父類，那不如就直接給它起個名字。

// 首先定義兩個類型別名
type Row = List[Int]
type Matrix = List[Row]
//trait Det extends (Matrix => Int)
// 同樣不需要額外繼承，直接使用別名定義行列式
type Det = Matrix => Int

// 我們還可以針對類型別名使用函數組合來定義
val DetStep1: Matrix => Row = (m: Matrix) => m.head
val DetStep2: Row => Int = (r: Row) => r.head

val mtxDet: Det = DetStep1 andThen DetStep2

看起來非常方便，唯一需要注意的是，類型別名對于編譯器來說，真的就是別名，而不是新的類型。比如對于剛才的例子，編譯器解讀的是

val DetStep2: List[Int] => Int = (r: List[Int]) => r.head

• 抽象類

抽象類可以按照如下的方式定義

abstract class Shape {
        def getArea():Int    // subclass should define this
      }

抽象類不定義具體的方法實現，由子類去實現；
不能創建抽象類的實例。
也正是因為無法定義抽象類的實例，在抽象類中直接定義方法，就沒什么意義了。當然你如果非要定義，也是可以的。只是就失去了靈活性，那抽象類存在的意義是什么？

• 特質

特質和抽象類看起來很類似，一個extendable，一個使用with，都是延展了父類的繼承方式。

trait Car {
  val brand: String
}

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

這里可以看的出一點區別就是：
只能extend一個abstract class，但是可以extend多個trait。
那什么時候使用它們呢？這要理解一下它倆還有啥區別：
abstract class可以有帶參數的構造器，但是trait不行，也就是如下：

// 不合法
scala> trait Car(rr: Int) {val brand: String}
<console>:1: error: traits or objects may not have parameters
       trait Car(rr: Int) {val brand: String}
//下面這個是合法的
scala> abstract class Shape(r: Int) {def getArea():Int    // subclass should define this}
     | }
defined class Shape

trait可以有多個，但abstract不行。
看起來比較清晰，但實際上為什么要設置這種區別？
抽象類是對一個大類群體的抽象，比如動物-哺乳動物-靈長類-人，動物就是抽象類，包含了所有的動物特性，比如都有dna，都呼吸等等。
特質則是顧名思義，對一些非階層化特點的補充，比如發聲這個就適合當作特質，因為哺乳動物可能會發聲，而昆蟲也可能會發聲，這種特性是跨越了動物綱目分類的，很適合按照擴展或混入的方式加入到某個子類。

• 泛型參數
  不一定要具體制定類型，也可以使用泛型。

trait Cache[K, V] {
  def get(key: K): V
  def put(key: K, value: V)
  def delete(key: K)
}
//方法也可以引入類型參數。

def remove[K](key: K)