变量、常量和数据类型
var
var修饰的是变量，variable，值是可变的
var 变量名 [: 变量类型] = 变量值
scala> var age : Int = 23
age: Int = 23
scala> var age = 23 //这里的变量类型可以省略不写，scala会自行推断
age: Int = 23
scala> age = 25
age: Int = 25
scala> age
res1: Int = 25
val
val修饰的是常量，值是不可变的
val 常量名 [: 常量类型] = 常量值
scala> val sex : String = "男" //类似于java中的final
sex: String = 男
scala> val sex = "男"
sex: String = 男
scala> sex = "女"
<console>:12: error: reassignment to val //因为是常量，所以不能修改
sex = "女"
^
数据类型
和java一样，有7种数值类型：Byte,Char,Short,Int,Long,Float,Double和一种Boolean类型
scala中对大小写很敏感，一定要写对大小写
在scala中数据类型的本质是对象，可以调用对应的方法
scala> 1 + 1 //1 + 1的本质并非是数值相加
res2: Int = 2
scala> 1.+(1) //其实是1作为Int类型，在scala中是对象，可以调用+方法
res3: Int = 2
条件表达式
scala> val a = 1
a: Int = 1
scala> val b = if (a > 1) 1 else -1
b: Int = -1
scala> val b = if (a > 1) 1 else "allen"
b: Any = allen //此处的Any相当于java中的Object
scala> val b = if (a > 1) 1
b: AnyVal = () //此处的AnyVal是Any的直接子类
//以上的scala语句就相当于java中的if语句，不过要简便很多
int a = 1;
if (a > 1) {
a = 1;
} else {
a = Integer.parseInt("allen");
}
Any：是scala中所有类的超类/父类，相当于java中的Object
AnyRef：是所有引用类型的父类
AnyVal：是所有基本类型的父类
scala> val b = if (a > 1) 1 else "allen"
b: Any = allen
//以上的完整形式应该是
scala> val b = if (a > 1){
1
} else {
"allen"
}
b: Any = allen
所以scala语法比java更灵活，{}内如果只有一个表达式时，{}可以省略
而且支持混合类型表达式，比如上面1是Int类型，allen是String类型，最后输出为AnyVal类型
scala Unit：表示返回空值，相当于java中的void。Unit有一个唯一的实例 ()
块表达式
scala> val a = 1
a: Int = 1
scala> val b = {
| val c = a + 1
| val d = c * 3
| d}
b: Int = 6
scala> val b = {
| val c = a + 1
| val d = c * 3
| 12345}
b: Int = 12345
{}括起来的一段代码逻辑称为代码块。看上图，代码块执行的结果一直都是最后一个表达式的结果。
to循环
scala> 1 to 10
res6: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) //相当于java中的[1,10]
for循环
for (形式参数 <- 表达式|数组|集合)
scala> val a1 = Array(11,12,13)
a1: Array[Int] = Array(11, 12, 13)
scala> for(i <- a1) println(i)
11
12
13
scala> for(i <- a1) println(i * 10)
110
120
130
for推导式
scala> val a1 = Array(11,12,13)
a1: Array[Int] = Array(11, 12, 13)
scala> for (i <- a1) yield i * 10
res8: Array[Int] = Array(110, 120, 130)
将yield后面的表达式作用于for循环的结果，并返回构成一个新的集合
scala中的方法和函数
方法的定义
识别方法的重点是关键字def
def 方法名(参数名1:类型,参数名2:类型,...):返回类型 = {方法体}
注意事项：
1.针对返回结果类型，通常情况下可以不写，但是递归方法除外，需要制定返回类型
2.针对方法体，如果逻辑简单，{}可以省略
3.针对输入参数列表，如果是无参数输入，()可以不写
函数的定义
识别方法的重点是 =>
val 函数名称 = (参数1:类型,参数2:类型,...) => {函数体}
scala> val f1 = (x : Int,y : Int) => x + y
f1: (Int, Int) => Int = <function2>
scala> f1(1,2)
res0: Int = 3
注意事项：
1.如果没有常量或者变量引用，函数称之为匿名函数
2.函数体简单，{}可以省略不写
3.也可以定义无参数函数
函数和方法的区别
1.在函数式编程语言中，函数是头等公民
2.函数本身是对象，具有自己的方法
andThen apply compose toString
3.函数可以当成其他数据类型一样，作为参数传递给方法
4.通常情况下，使用匿名函数作为参数传递
scala> def m1(x : Int,y : Int) = x + y //普通方法，接受两个Int，返回一个Int
m1: (x: Int, y: Int)Int
scala> def m2(f:(x : Int,y : Int) => Int) = f(2,3)
<console>:1: error: ')' expected but ':' found. //定义格式错误
def m2(f:(x : Int,y : Int) => Int) = f(2,3)
^
scala> def m2(f:(Int,Int) => Int) = f(2,3) //函数式方法，接受一个参数，类型为函数
m2: (f: (Int, Int) => Int)Int //且要求是输入两个Int,返回一个Int的函数
scala> def f1 = (x : Int) => x + 1 //函数：接收一个Int，返回一个Int
f1: Int => Int
scala> def f2 = (x : Int,y : Int) => x + y //函数：接收两个Int，返回一个Int
f2: (Int, Int) => Int
scala> m2(f2) //f2符合m2的参数类型，就可以把函数作为参数传递给方法
res1: Int = 5
scala> m2((x:Int,y:Int)=>x+y) //以匿名的形式传递给方法
res3: Int = 5
5.方法可以转换为函数
scala> def m2(f:(Int,Int) => Int) = f(2,3)
m2: (f: (Int, Int) => Int)Int
scala> def m1(x:Int,y:Int)=x+y
m1: (x: Int, y: Int)Int
scala> m1 _
res4: (Int, Int) => Int = <function2>
scala> m2(m1 _)
res5: Int = 5
scala> m2(m1) //scala作了隐式转换，把方法变成了函数
res6: Int = 5
相当于：
scala> val f1 = m1 _
f1: (Int, Int) => Int = <function2>
scala> m2(f1)
res7: Int = 5