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

• （有名）函數(shù)

相對于下面的匿名函數(shù)而言兴使。它有名字思灌。

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

一目了然，這個函數(shù)名字為addOne舌仍，接受一個x整形參數(shù)妒貌，函數(shù)的輸出為Int，實現(xiàn)的動作是+1铸豁。

• 匿名函數(shù)

(x: Int) => x + 1

從什么到什么灌曙，即為函數(shù)。和數(shù)學(xué)里的一樣节芥，表達(dá)一種映射關(guān)系在刺，比如從x->y，從自變量到因變量的對應(yīng)關(guān)系头镊。

Scala支持匿名函數(shù)蚣驼，表達(dá)形式和數(shù)學(xué)式高度一致，(input: Type) => output

那么匿名函數(shù)是沒有名字的相艇，每次使用難道都要寫完整的函數(shù)颖杏？不是。

匿名函數(shù)沒有名字坛芽，但依舊可以給它一個變量名留储。即：

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

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

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

• 部分應(yīng)用(Partial application)

假設(shè)我們有一個函數(shù)
def addTwo(a: Int, b: Int) :Int = a + b
這個函數(shù)有兩個參數(shù)，a和b〗岣浚現(xiàn)在我們的需求變了损晤，我們希望將a的值固定下來，比如a=2.我們可以定義一個新的函數(shù)红竭，只接受一個參數(shù)尤勋。
def addA(b: Int): Int = 2 + b
這樣當(dāng)然是可以的喘落。但能不能利用現(xiàn)有的addTwo這個函數(shù)，直接生成一個呢最冰？這個需求就是部分應(yīng)用的存在意義瘦棋。因為不需要重新定義個函數(shù)了，所以我們就不用def了暖哨，否則就是如上的形式赌朋。這里我們使用匿名函數(shù)。

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

那這個方式篇裁，能不能直接用在匿名函數(shù)本身呢沛慢？比如我們有

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

可不可以直接使用部分應(yīng)用？答案是可以的达布。

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

• 柯里化函數(shù)
  首先团甲，什么是柯里化？
  簡單來說往枣，當(dāng)一個函數(shù)需要多個參數(shù)時伐庭，我們一般把這種需要理解為同時需要。比如分冈，計算舉行面積畔裕，我們需要長和寬捶闸，當(dāng)這兩個條件都具備時，我們才可以計算出面積。下面這個三個數(shù)相乘的函數(shù)也可以這么理解退唠。
  def area(w: Int, l: Int) = w * l
  但我們能不能有時候換個角度理解丰涉，把這種同時需要的并行關(guān)系褂乍，理解為一種逐個需要的線性關(guān)系帖渠。也就是說，當(dāng)有a之后倔叼，我們需要b汗唱，然后我們需要c，最后我們可以算出結(jié)果丈攒。
  這么做的理由和需求是什么哩罪？想象一下矩形面積問題，原本的需求是：
  • 計算一個矩形的面積巡验，需要處理的矩形w和l都是未知的际插；
    但如果需求變了，
  • 計算一個矩形的面積显设，它們的w是已知的框弛；
    我們會很自然的想到利用部分應(yīng)用，也就是

val areaWithW = area(3, _: Int)

這個想法很自然捕捂，但這里有一個隱含假設(shè)瑟枫，即我們不僅知道w是已知的斗搞，而且我們現(xiàn)在就知道了。但如果我們將來才知道呢慷妙？或者這個已知的w本身并不是一個固定的值榜旦，而是若干值，那我們是不是每次只有在這些值已知的時候景殷，才能定義出如上面這樣的函數(shù)，而不能提前定義出來澡屡？
這個需求確實有點具體猿挚，所以其實更容易理解的，還是并行和線性的比方驶鹉。
柯里化之后的函數(shù)绩蜻，原本并行著的參數(shù)，會形成一串線性的參數(shù)室埋，每當(dāng)一個確定了一個參數(shù)办绝，剩下的部分依舊是個柯里化的函數(shù)，直到只剩一個參數(shù)為止姚淆，到此函數(shù)變成一個單一參數(shù)的函數(shù)孕蝉。用下面的三個數(shù)乘法舉例。

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

從函數(shù)的形態(tài)腌逢，我們可以看清楚這種變化的關(guān)系降淮，柯里化之后的函數(shù)是

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

如果回到數(shù)學(xué)式子

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

所以，柯里化是一種函數(shù)對應(yīng)關(guān)系的變化搏讶。而具體的某一個柯里化的結(jié)果比如
area(1)(2)
則可以看作是一種部分應(yīng)用了佳鳖，即

area(1, 2, _: Int)。

• 可變長度參數(shù)

含義很明確媒惕，如果一個方法有多個參數(shù)系吩，且并不知道具體有多少個，可以采用如下的形式妒蔚。

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

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

• 構(gòu)造函數(shù)

構(gòu)造函數(shù)在scala和在Java看起來很不同穿挨。在Java中，是如下的形式：

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

    public static void main(String[] args){

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

構(gòu)造函數(shù)很明確的指定了參數(shù)面睛。當(dāng)然絮蒿，不同的參數(shù)組成，就需要不同的構(gòu)造器叁鉴。
Scala的則不同土涝，更簡潔，但可能也會造成更不習(xí)慣幌墓，如果你習(xí)慣了java的但壮。

class Calculator(brand: String) {//構(gòu)造器
  /**
   * 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的構(gòu)造器冀泻，實際上就是類名稱旁邊的那部分參數(shù)列表了，因為不再需要單獨的一個method蜡饵。不過這樣帶來了一個問題弹渔，java的構(gòu)造器和參數(shù)，不一定是public的溯祸。而scala的做法是將參數(shù)放在類名稱旁邊肢专，并自動生成一個public構(gòu)造方法以及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)
}

類型別名的意思惠险，就是可以給類型命名苗傅，也就是自定義一個(復(fù)雜)類型，比如如下的情況班巩。

type Row = List[Int] //給List[Int]起名字為Row金吗，很好的解釋了數(shù)學(xué)中的行的概念
type Matrix = List[Row] //給行的列表起名為Matrix，很直觀

可以發(fā)現(xiàn)趣竣，用type alias起名字摇庙，可以更直觀的表達(dá)比較復(fù)雜的類型。
除此之外遥缕，還可以用如下的形式來使用類型別名卫袒。這樣的好處是，如果你要繼承的東西并沒有改變父類单匣，那不如就直接給它起個名字夕凝。

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

// 我們還可以針對類型別名使用函數(shù)組合來定義
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
      }

抽象類不定義具體的方法實現(xiàn)鲸伴，由子類去實現(xiàn)府蔗；
不能創(chuàng)建抽象類的實例晋控。
也正是因為無法定義抽象類的實例，在抽象類中直接定義方法姓赤，就沒什么意義了赡译。當(dāng)然你如果非要定義，也是可以的不铆。只是就失去了靈活性蝌焚，那抽象類存在的意義是什么？

• 特質(zhì)

特質(zhì)和抽象類看起來很類似誓斥，一個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
}

這里可以看的出一點區(qū)別就是：
只能extend一個abstract class，但是可以extend多個trait舞吭。
那什么時候使用它們呢泡垃？這要理解一下它倆還有啥區(qū)別：
abstract class可以有帶參數(shù)的構(gòu)造器，但是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不行。
看起來比較清晰惧浴，但實際上為什么要設(shè)置這種區(qū)別存和？
抽象類是對一個大類群體的抽象，比如動物-哺乳動物-靈長類-人衷旅，動物就是抽象類捐腿，包含了所有的動物特性，比如都有dna柿顶，都呼吸等等茄袖。
特質(zhì)則是顧名思義，對一些非階層化特點的補充嘁锯，比如發(fā)聲這個就適合當(dāng)作特質(zhì)宪祥，因為哺乳動物可能會發(fā)聲，而昆蟲也可能會發(fā)聲家乘，這種特性是跨越了動物綱目分類的蝗羊，很適合按照擴展或混入的方式加入到某個子類。

• 泛型參數(shù)
  不一定要具體制定類型仁锯，也可以使用泛型耀找。

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

def remove[K](key: K)