Scala_基础

匿名函数

scala>(x: Int) => x + 1

如果匿名函数有很多表达式，可以使用{}格式化代码

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

部分应用

可以使用下划线“_”部分应用一个函数，结果将得到另一个函数。scala使用下划线表示不同上下文中的不同事物，你通常可以把它看做是一个没有命名的神奇通配符。

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

可以部分应用参数列表中的任意参数，不仅仅是最后一个

柯里化参数

有时会有这样的需求：允许别人一会在你的函数上应用一些参数，然后又应用另外一些参数

比如一个乘法函数，在一个场景需要选择乘数，在另一个场景需要选择被乘数

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

你可以直接传入两个参数

scala>multiply(2)(3)

可以填上第一个部分并且部分应用第二个参数

scala>val timesTwo = multiply(2) _

scala>timesTwo(3)

可以对任何多参数函数执行柯里化，例如之前的adder函数

scala>(adder _).curried

可变长度参数

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

类

scala>class Calculator{
  val brand: String="HP"
  def add(m: Int,n: Int):Int = m + n
}

scala>val calc = new Calculator
scala>calc.add(1,2)
scala>calc.brand

上例展示了如何在类中用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")
scala> calc.color
res0:String = black

scala是高度面向表达式的，比如上述例子颜色就是绑定在一个if/else表达式上，大多数东西都是表达式而非指令

函数和方法在很大程度上是可以互换的。

继承

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

重载方法

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
}

scala> class circle(r: Int) extends Shape {
  def getArea():Int = {r*r*3}
}

特质（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对特质的观点

什么时候应该使用特质而不是抽象类？

如果你想定义一个类似接口的类型，你可能会在特质和抽象类之间难以取舍。这两种形式都可以让你定义一个类型的一些行为，并要求继承者定义一些其他行为。一些经验法则：

1. 优先使用特质，一个类扩展很多特质是可以实现的，但是只能扩展一个抽象类
2. 如果你需要构造函数参数，使用抽象类。因为抽象类可以定义带参数的构造函数，而特质不行

类型

此前我们定义一个函数的参数为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)