Scala基础语法

一、scala中声明变量

1、语法格式

val/var 变量名称:变量类型 = 初始值

val定义的是不可重新赋值的变量(值不可修改)
var定义的是可重新赋值的变量(值可以修改)
注：

• scala中声明变量是变量名称在前，变量类型在后，跟java是正好相反
• scala的语句最后不需要添加分号

2、示例

#使用val声明变量,相当于java中的final修饰,不能在指向其他的数据了
 val  a:Int = 10
#使用var声明变量,后期可以被修改重新赋值
 var  b:Int = 20	 
 b=100
#scala中的变量的类型可以显式的声明,也可以不声明,如果不显式的声明这会根据变量的值来推断出来变量的类型(scala支持类型推断)
 val c = 20

3、惰性变量

• Scala中使用关键字lazy来定义惰性变量，实现延迟加载(懒加载)。
• 惰性变量只能是不可变变量，并且只有在调用惰性变量时，才会去实例化这个变量。
• 语法格式

lazy val/var 变量名 = 表达式

二、 scala中数据类型

• scala中的类型绝大多数和Java一样
• 数据类型

基础类型	类型说明
Byte	8位带符号整数
Short	16位带符号整数
Int	32位带符号整数
Long	64位带符号整数
Char	16位无符号Unicode字符
String	Char类型的序列（字符串）
Float	32位单精度浮点数
Double	64位双精度浮点数
Boolean	true或false

• 注意下 scala类型与Java的区别

1. scala中所有的类型都使用大写字母开头
2. 整形使用Int而不是Integer
3. scala中定义变量可以不写类型，让scala编译器自动推断

scala类型层次结构

类型	说明
Any	所有类型的父类，,它有两个子类AnyRef与AnyVal
AnyVal	所有数值类型的父类
AnyRef	所有对象类型（引用类型）的父类
Unit	表示空，Unit是AnyVal的子类，它只有一个的实例（），它类似于Java中的void，但scala要比Java更加面向对象
Null	Null是AnyRef的子类，也就是说它是所有引用类型的子类。它的实例是null, 可以将null赋值给任何对象类型
Nothing	所有类型的子类不能直接创建该类型实例，某个方法抛出异常时，返回的就是Nothing类型，因为Nothing是所有类的子类，那么它可以赋值为任何类型

三、scala中的条件表达式
条件表达式就是if表达式，if表达式可以根据给定的条件是否满足，根据条件的结果（真或假）决定执行对应的操作。scala条件表达式的语法和Java一样。

//定义变量x
scala> val x =1
x: Int = 1

//if表达式
scala> val y =if(x>0) 1 else -1
y: Int = 1

//支持混合类型表达式
scala> val z=if(x>1) 1 else "error"
z: Any = error

//缺失else 相当于 if(x>2) 1 else ()
scala> val m=if(x>2) 1
m: AnyVal = ()

//scala中有个Unit类，用作不返回任何结果的方法的结果类型,相当于Java中的void，Unit只有一个实例值，写成()
scala> val n=if(x>2) 1 else ()
n: AnyVal = ()

//if(xx) else if(xx) else 
scala> val k=if(x<0) -1 else if (x==0) 0 else 1
k: Int = 1

四、scala中的块表达式
定义变量时用 {} 包含一系列表达式，其中块的最后一个表达式的值就是块的值。

val x=0 
val result={
  val y=x+10
  val z=y+"-hello"  
  val m=z+"-kaikeba"
    "over"
}
//result的值就是块表达式的结果    
//后期一个方法的返回值不需要加上return,把要返回的结果放在方法的最后一行就可以了 

在scala解释器中先输入 :paste ,然后写多行代码, 之后按=ctrl+d结束输入
五、循环

在scala中，可以使用for和while，但一般推荐使用for表达式，因为for表达式语法更简洁

1、for循环

• 语法结构

for (i <- 表达式/数组/集合){
    //表达式
}

• 示例

//简单的for循环
scala> val nums= 1 to 10
nums: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> for(i <- nums) println(i)
1
2
3
4
5
6
7
8
9
10

//双重for循环
scala>  for(i <- 1 to 3; j <- 1 to 3) println(i*10+j)
11
12
13
21
22
23
31
32
33

//双重for循环打印99乘法表
for(i <- 1 to 9; j <- 1 to i){
    print(i+"*"+j+"="+i*j+"\t")
     if(i==j){
       println()
    }    
} 

1*1=1
2*1=2   2*2=4
3*1=3   3*2=6   3*3=9
4*1=4   4*2=8   4*3=12  4*4=16
5*1=5   5*2=10  5*3=15  5*4=20  5*5=25
6*1=6   6*2=12  6*3=18  6*4=24  6*5=30  6*6=36
7*1=7   7*2=14  7*3=21  7*4=28  7*5=35  7*6=42  7*7=49
8*1=8   8*2=16  8*3=24  8*4=32  8*5=40  8*6=48  8*7=56  8*8=64
9*1=9   9*2=18  9*3=27  9*4=36  9*5=45  9*6=54  9*7=63  9*8=72  9*9=81

• 守卫
  在for表达式中可以添加if判断语句，这个if判断就称为守卫

//语法结构
for(i <- 表达式/数组/集合 if 表达式) {
    // 表达式
}

scala> for(i <- 1 to 10 if i >5) println(i)
6
7
8
9
10

• for推导式
  在for循环体中，可以使用yield表达式构建出一个集合，我们把使用yield的for表达式称之为推导式

// for推导式：for表达式中以yield开始，该for表达式会构建出一个集合

val v = for(i <- 1 to 5) yield i * 10

2、while循环

• scala中while循环和Java中是一致的
• 语法结构

while(返回值为布尔类型的表达式){
    //表达式
}

• 演示

scala> var x = 10
x: Int = 10

scala> while(x >5){
     | println(x)
     | x -= 1
     | }
10
9
8
7
6