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。现在我们的需求变了，我们希望将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)