零、准备工作
我使用的java1.8.112, scala2.11.8, CentOS7上学习的，通过命令行学习，安装教程看我写的这个教程。
一、表达式
不指定接收变量或者值的语句
如： scala> 1+3
res0: Int = 4
这里就是只有1+3，不用管结果赋给谁，解释器会自动创建一个值（这里是res0，这个res就是result，0是表示第一个，从0开始，后面再有一个表达式就是res1，…,这些自动创建的值也是可以当成我们自己创建的值使用的，注意：我说的是创建值，不是变量，下面就会讲他们的区别）。
二、值
你可以给一个表达式的结果起个名字赋成一个不变量（val）。
scala> val a=1
a: Int = 1
scala> a=2
<console>:12: error: reassignment to val
a=2
^可以看出来val定义的值是不能修改的。
三、变量
如果你需要修改这个名称和结果的绑定，可以选择使用var。
scala> var money=123021
money: Int = 123021
scala> money=99999999
money: Int = 99999999通过var定义的变量的值是可以修改的。
四、函数
你可以使用def创建函数.
scala> def getOne() => 1
<console>:1: error: '=' expected but '=>' found.
def getOne() => 1
^
scala> def getOne() = 1
getOne: ()Int
scala> getOne //一个参数的可以加括号也可以不加
res6: Int = 1
scala> getOne()
res7: Int = 1
scala> def print(x:String)=x //定义一个函数，含有一个String类型的参数
print: (x: String)String
scala> print() //定义的是带有一个参数的当然调用就不能不带参数咯，咱都知道的^^
<console>:13: error: not enough arguments for method print: (x: String)String.
Unspecified value parameter x.
print()
^
scala> print('1') //类型检查还是挺像Java的呀
<console>:13: error: type mismatch;
found : Char('1')
required: String
print('1')
^
scala> print("1")
res11: String = 1
scala> def multi(a:Double, b:Double): Double=a*b //定义一个函数，含有两个Double类型的参数，返回值类型也是Double。
multi: (a: Double, b: Double)Double
scala> multi(2.0,3.0)
res12: Double = 6.0继续测试函数
scala> def devide(a:Double, b:Int):Int=a/b
<console>:12: error: type mismatch;
found : Double // a/b的结果是Double类型的，但是返回类型是Int类型的，编译不通过
required: Int
def devide(a:Double, b:Int):Int=a/b
^
scala> def devide(a:Double, b:Double):Double=a/b
devide: (a: Double, b: Double)Double
scala> devide(10, 15)
res13: Double = 0.6666666666666666
scala> devide(10, 10)
res14: Double = 1.0
scala> def devide(a:Int, b:Int):Int=a/b
devide: (a: Int, b: Int)Int
scala> devide(10, 12)
res15: Int = 02：匿名函数
def dealWith(x:Int):Int={
println(x)
x*3
}
//下面的代码就是相当于上面的代码的相似的匿名函数，只是我没有写的一模一样
{ x:Double=>
println("x="+x)
x*10/3
}
2、
scala> val func=(x:Int) => x*45-12 //最基本的匿名函数，可以赋给值，也可以不定义，scala会自动创建值保存匿名函数
func: Int => Int = <function1>
scala> func(10)
res30: Int = 438五、部分应用
scala> def add(a:Int, b:Int)=a+b //函数使用def开头，匿名函数表达式可以使用val或者是var去保存
add: (a: Int, b: Int)Int
scala> val sum=add(20, _:Int)
sum: Int => Int = <function1>
scala> sum(10)
res31: Int = 30
scala> val sum=add(_:Int, 10) //可以写在任意地方，相当于变量占位符，不一定要写在最后
sum: Int => Int = <function1>
scala> sum(10)
res32: Int = 202、柯里化函数
一个参数可以随意部分应用的函数，也是上面的部分应用的高级版。
scala> def multi(f:Int)(t:Int)=f*t //定义一个柯里化函数，每个变量一个括号
multi: (f: Int)(t: Int)Int
scala> multi(2)(3) //参数全使用
res35: Int = 6
scala> val two=multi(2)_ //固定第一个参数，使用第二个参数
two: Int => Int = <function1>
scala> two(3)
res36: Int = 6
scala> val first=multi(_:Int)(3) //固定第二个参数，使用第一个参数
first: Int => Int = <function1>
scala> first(2)
res37: Int = 6
scala> (add _).curried //对正常函数柯里化，不改变原函数，生成一个匿名的新柯里化的函数
res39: Int => (Int => Int) = <function1>
scala> res39(2)(3)
res41: Int = 53、可变长度的参数
这是一个特殊的语法，可以向方法传入任意多个同类型的参数，例如要在多个字符串上执行String的capitalize函数，可以这样写
scala> def capitalizeAll(args:String*)={ args.map(arg=> arg.capitalize ); } //里面是一个函数表达式
capitalizeAll: (args: String*)Seq[String]
scala> capitalizeAll("dog", "cat")
res45: Seq[String] = ArrayBuffer(Dog, Cat)