Scala的基本语法
Scala的数据类型
在scala中，有以下数据类型。例如：
Byte、Char、Short、Int、Long、Float、Double、Boolean
Any是abstract类，它是Scala类继承结构中最底层的。所有运行环境中的Scala类都是直接或间接继承自Any这个类。(any 是所有类的超类)
AnyVal 所有值类型的基类。
Nothing是所有类的子类，是一个类。Nothing没有对象，但是可以用来定义类型。
scala> def foo = throw new RuntimeException
foo: Nothing
Null是所有AnyRef的子类，null是Null的唯一对象。
变量的定义
分为强类型语言和弱类型语言
强类型语言：Java
int num=10;
char ch=”a”;
Double num2=11.11;
弱类型语言：JS、Scala
var x=111;
var y=11.11;
var z=”hello”;
val f=58;
var定义变量；val定义常量
object VariableTest {
def main(args: Array[String]) {
//使用val定义的变量值是不可变的，相当于java里用final修饰的变量
val i = 1
//使用var定义的变量是可变的，在Scala中鼓励使用val
var s = "hello"
//Scala编译器会自动推断变量的类型，必要的时候可以指定类型
//变量名在前，类型在后
val str: String = "world"
}
}
基本操作符
基本操作符主要分为三类：算术运算符、关系运算符和逻辑运算符
scala的算术操作符与java的算术操作符也没有什么区别，比如+、-、*、/、%等，以及&、|、^、>>、<<等。
但是，在scala中，这些操作符其实是数据类型的方法，比如1 + 1，可以写做1.+(1)
例如，1.to(10)，又可以写做1 to 10
scala中没有提供++、--操作符，我们只能使用+和-，比如num = 1，num ++是错误的，必须写做num += 1。
字符串的插值操作
Scala中的三个字符串插值器：s、f、raw
var name = "tom"
//name: String = tom
var src = s"hello ${name}"
//src: String = hello tom
val name1 = "tom"
val name2 = "jim"
println(s"hello,${name1 +","+ name2}!")
条件表达式
If
If else（单分支）
If else if else（多分支）
在条件表达式中可以返回不同类型的值，并且在返回类型不一致时会使用any类型。
def main(args: Array[String]): Unit = {
val x = 1
//判断x的值，将结果赋给y
val y = if (x > 0) 1 else -1
//打印y的值
println("y=" + y)
//支持混合类型表达式
val z = if (x > 1) 1 else "error"
//打印z的值
println("z=" + z)
//如果缺失else，相当于if (x > 2) 1 else ()
val m = if (x > 2) 1
println("m=" + m)
//在scala中每个表达式都有值，scala中有个Unit类，写做(),相当于Java中的void
val n = if (x > 2) 1 else ()
println("n=" + n)
}
scala> val y = if(1>1) 1 else "error"
y: Any = error
当y的值类型既可能为Int又可能为String时，它的类型被定义为Any，是Int和String的父类。
scala> val y = if(x>1) 1
y: AnyVal = ()
没有else时，会默认为else （），
y的类型被定义为AnyVal
类型的转换
string类型的不能直接加数字，需要转换成整数或浮点数
val num = "11"
// num:Stringt = 11
val num_int = num.toInt
//num_int : Int = 11
println(num_int+22)
//33块表达式
def main(args: Array[String]): Unit = {
val x = 0
val result = {
if(x < 0)
1
else if(x >= 1)
-1
else
"error"
}
println(result)
}
循环语句
for循环
( to 和 until 关键字的用法，to 表示闭区间（包含终止值），而 until 表示左闭右开区间（不包含终止值）)
scala>for (i <- 1 to 10) println(i)
// 打印1到10
1
2
3
4
5
6
7
8
9
10
scala> 1 to 10
res6: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
scala>for (i <- 1 until 10) println(i)
// 打印1到9
//包含开头不包含结尾
1
2
3
4
5
6
7
8
9scala> 1 until 10
res0: scala.collection.immutable.Range = Range(1, 2, 3, 4, 5, 6, 7, 8, 9)
遍历字符串：
遍历字符串和数组，强调了索引从零开始，使用 until 时无需减一。
相当于java中的fore
scala> val str = "hello"
str: String = hello
scala> for(c <- str) println(c)
h
e
l
l
o
通过下标遍历字符串：
scala> for (i <- 0 until str.length) println(str.charAt(i))
h
e
l
l
o
遍历数组：
scala> val arr = Array(1,2,3,4,5,6)
arr: Array[Int] = Array(1, 2, 3, 4, 5, 6)
scala> for(a <- arr) println(a)
1
2
3
4
5
6
通过下标遍历数组：
scala> for(i <- 0 until arr.length) println(arr(i))
1
2
3
4
5
6
双重循环：
嵌套循环：在 scala中，双重循环不需要嵌套 for 语句，直接在一个 for 循环内声明另一个 for 循环的条件即可。
// 输出个位数与十位数不相同的两位数（个位、十位数均从1-3取值）
scala> for(i <- 1 to 3;j <- 1 to 3 if i != j) println(i*10+j)
12
13
21
23
31
32
数组操作：
对数组中的每个数乘以10，生成一个新数组：
scala> val arr = Array(1,2,3,4,5,6)
arr: Array[Int] = Array(1, 2, 3, 4, 5, 6)
scala> for(i<- arr)println(i*10)
10
20
30
40
50
60
scala> for(i<- 0 until arr.length)println(arr(i)*10)
10
20
30
40
50
60
while循环
while循环：基本语义与Java相同。
var n = 10
while(n > 0) {
println(n)
n -= 1
}
10
9
8
7
6
5
4
3
2
1do while循环
至少被执行一次。
先进入循环体再判断条件，示例展示了从 1 开始每次加 2 直到小于 10 的过程。
var n =1
do{
println(n)
n+=2
}while(n<10)
1
3
5
7
9
操作符重载
在scala里面没有运算符，所有的符号其实都是方法
scala> val a = 1.+(2)
a: Int = 3
scala中没有运算符重载，所有操作都是通过方法调用实现的。
相当于是，1这个实例调用+方法，传入了一个参数2
定义一个+方法：
scala> def +(x : Int,y : Int):Int = { x + y }
$plus: (x: Int, y: Int)Int
scala> $plus(10,30)
res15: Int = 40
scala> def +(num1:Int,num2:Int):Int = {num1+num2}
$plus: (num1: Int, num2: Int)
//举例
scala> +(1, 2)
res0: Int = 3
scala> $plus(10,10)
res0: Int = 20