Scala学习-第一课

零、准备工作
我使用的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 = 0

2：匿名函数

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 = 20

2、柯里化函数
一个参数可以随意部分应用的函数，也是上面的部分应用的高级版。

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 = 5

3、可变长度的参数
这是一个特殊的语法，可以向方法传入任意多个同类型的参数，例如要在多个字符串上执行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)