= 和=>

• 函数类型推断
  此时没有写返回值,但是有等号,函数会自己推断返回值,此时的返回值是Int

def add(x:Int,y:Int) = {
    x+y
}

此时没有写返回值,也没有等号,无论函数内部有没有返回值,返回值都是Unit

def add(x:Int,y:Int){
    x+y
}

• 如果函数仅包含一条语句，那么连花括号都可以选择不写
  def add(x:Int,y:Int) = x+y
• => 在匿名函数中，用于分隔入参和函数体， 例如： val f = (x: Int) => x + 1

小括号和花括号

• 当方法的参数只有一个时，两个是等价的。例如 List(10) 等价于 List{10}
• 花括号可以完成部分数据的初始化
  例如：
  
val l = List {
val x = 10
x + 20
}


可变长参数

def echo(args: String*)

Lazy

lazy val property = initProperty() lazy关键字修饰变量后，只有在使用该变量时，才会调用其实例化方法。在实例化时，还会加锁，多线程安全。

Implict

参考：
http://www.voidcn.com/article/p-dvaxxgng-gt.html

泛型

override def apply[A](xs: A*): List[A] = xs.toList
class List[+A]

def ::[B >: A] (x: B): List[B] =
new scala.collection.immutable.::(x,this)

Partial Functions(偏函数)

• 只接受和处理其参数定义域范围内的子集，对于这个参数范围外的参数则抛出异常的函数

例如：PartialFunction[A,B],其中接收一个类型为A的参数，返回一个类型为B的结果
* def isDefinedAt(x: A): Boolean 判断传入来的参数是否在这个偏函数所处理的范围内

完整偏函数例子

val divide = new PartialFunction[Int,Int] {
def isDefinedAt(x: Int): Boolean = x != 0 //判断x是否等于0，当x = 0时抛出异常
def apply(x: Int): Int = 100/x
}　　

结合case语句

val divide1 : PartialFunction[Int,Int] = {
case d : Int if d != 0 => 100/d //功能和上面的代码一样，这就是偏函数的强大之处，方便，简洁！！
}　

多个case使用

val rs : PartialFunction[Int,String] = {
case 1 => "One"
case 2 => "Two"
case _ => "Other"
}

• 如果使用匿名函数，还可以使用case 语句中输入的变量类型来进行数据过滤
  List(1,3,5,"seven") collect { case i: Int => i + 1 }

• List 的map 和 collect

def map[B](f: (A) ? B): List[B] : 接收的是一个函数类型的参数
def collect[B](pf: PartialFunction[A,B]): List[B] 接收的是一个偏函数（partial function）类型的参数

• Case 语句声明的变量就是偏函数的参数，case语句只接受一个参数，则偏函数的类型声明自然就只有一个参数

Apply

• 对于函数来说该方法意味着调用function本身
  例如：
  val f = (x: Int) => x + 1
  我们可以通过调用函数 f 的apply方法来调用函数本身，即f.apply(3) ，scala提供更简单的调用方式 f(3)

• 作为工厂方法
  对于Object 对象来说，我们可以显示调用apply方法，例如 List.apply(1,2,3),等价于List(1,3) ，如果方法只有一个参数，等价于使用花括号List {1}

Future

• 使用前导入类

import scala.concurrent.Future 
import scala.concurrent.ExecutionContext.Implicits.global

使用示例：

Future {
  ...
}

在执行Future.apply{异步代码块}时，主线程将异步代码块交给新的线程，新起的线程负责异步代码块的计算，而主线程则解放出来，执行下一步。