Scala概述

Scala设计的目的是整合面向对象编程和函数式编程。Scala运行于Java平台（JVM），并兼容现有Java程序。

Java和Scala程序Hello World对比

object Main {

    def main(a: Array[String]) = {
        println("Hello World") //Scala结尾的;并不强求，写与不写没有区别
    }

}

注：最显著的一个区别就是Scala程序不需要通过static关键字将main方法标记为静态方法。

val和var的区别（常量与变量）

val x = 12 // val定义的是一个常量
x = 13 // 报错，不能修改常量的值，使用var定义的是一个变量，但是Scala推荐使用val，除非真的需要改变变量的值，因为val没有线程安全性问题，效率高
val name: String = "cai" // 也可以指定变量的类型
val name, msg = null // 可以同时初始化多个变量（无论使用var或val声明变量一定要初始化，不然报错）

Scala基本数据类型

Byte/Char
Short/Int/Long/Float/Double
Boolean

    val a = 1.1
    println(a.getClass()) //double
    val b = 1.2f
    println(b.getClass()) //float
    //val c:Float = 1.3 //报错：类型不匹配

    //类型转换函数
    val d = 10.asInstanceOf[Double]
    println(d.getClass()) //double

    //判断是否是某个类型
    val e = 10.isInstanceOf[Int]
    println(e) //true

lazy关键字

    lazy val a = 1 //a并没有被赋值
    println(a) //a才被赋值

注：Scala中使用关键字lazy来定义惰性变量，实现延迟加载；惰性变量只能是不可变变量，并且只有在调用惰性变量时，才会去实例化这个变量。

函数

    def max(x: Int, y: Int): Int = {
        if (x > y)
            x
        else
            y
    }

注：函数中最后一行就是函数的返回值

    def main(a: Array[String]) = {
        println(add())
        println(add) //当方法没有参数时可以省略小括号
    }

    //方法的返回值类型可以省略，因为Scala可以推断
    def add() = 1 + 2

函数默认参数

    def main(a: Array[String]) = {
        printName() // name:cai 注：这个时候小括号不能省略
        printName("zhong") //name:zhong
    }

    def printName(name: String = "cai") = {
        println("name:" + name)
    }

函数命名参数

    def main(a: Array[String]) = {
        println(speed(time = 10, distance = 100)) //10.0
    }

    //方法的返回值是Double
    def speed(distance: Double, time: Int) = {
        distance / time
    }

注：不建议使用该功能

函数可变参数

    def main(a: Array[String]) = {
        println(sumN("cai", 1, 2, 3)) //6
    }

    //可变参数一定要位于最后
    def sumN(name: String, nums: Int*) = {
        println(name) //cai
        var res = 0
        for (num <- nums) {
            res += num
        }
        res
    }

if语句

println("请输入年龄：")
val age = StdIn.readInt()
if (age < 18) {
    println("未成年人")
} else if (age < 50) {
    println("中年人")
} else {
    println("老年人")
}

注：Scala中没有switch语句

for循环

for (i <- 1 to 3) { //[]左闭右闭
    print(i) //Out:123
}

val list = List("a", "b", 1, 2, 12.5)
for (item <- list) {
    print(item + " ") //Out:a b 1 2 12.5
}
val arr = Array(1, 2, 3)
arr.foreach(item => {
    print(item + " ") //Out:1 2 3 
})

for (i <- 1 until 3) { //[)左闭右开
    print(i) //Out:12
}

主构造器和辅助构造器

object Main {

    def main(a: Array[String]) = {
        val p1 = new Person("cai", 12) //调用主构造器
        p1.printInfo() //cai12false

        val p2 = new Person("zhong", 13, true) //调用附属构造器
        p2.printInfo() //zhong13true
    }

}

class Person(name: String, age: Int) {
    //val不能使用占位符，因为val只能赋值一次，后面不能再次赋值；占位符也不能使用在局部变量中，因为局部变量声明的时候必须要初始化
    private var sex: Boolean = _ //默认值是false

    def this(name: String, age: Int, sex: Boolean) {
        this(name, age) //附属构造器的第一行代码必须要调用主构造器或其他附属构造器
        this.sex = sex
    }

    def printInfo() = {
        println(name + age + sex)
    }

}

继承

object Main {

    def main(a: Array[String]) = {
        val stu = new Student("cai", 18, "math")
        println(stu.name + stu.age)
        //println(stu.major) //错误：无法访问，要想访问必须要使用var或val修饰
    }

}

class Person(val name: String, val age: Int) {
    println("Person Constructor enter")
    println("Person Constructor leave")
}
class Student(name: String, age: Int, major: String) extends Person(name, age) {
    println("Student Constructor enter")
    println("Student Constructor leave")
}
Output:
Person Constructor enter
Person Constructor leave
Student Constructor enter
Student Constructor leave
cai18

重写

object Main {

    def main(a: Array[String]) = {
        val stu = new Student()
        stu.pr1() //Student pr1
        stu.pr2() //Person pr2
    }

}

class Person() {
    def pr1() = {
        println("Person pr1")
    }

    def pr2() = {
        println("Person pr2")
    }
}
class Student() extends Person() {
    override def pr1() = {
        println("Student pr1")
    }
}

抽象类

object Main {

    def main(a: Array[String]) = {
        val stu = new Stu
        println(stu.name) //cai
        stu.say //cai
    }

}

abstract class Person {
    val name: String
    def say
}

class Stu extends Person {
    override val name: String = "cai"
    override def say: Unit = {
        println(name)
    }
}

//----------------------

for循环守卫

for (i <- 1 to 3 if i != 2) {
    print(i) //Out:13
}

for循环引入变量

for (i <- 1 to 3; j = 4 - i) {
    print(j) //Out:321
}
//等价于
for (i <- 1 to 3) {
    val j = 4 - i
    print(j) //Out:321
}

嵌套循环

for (i <- 1 to 2; j <- 1 to 2) {
    print(i + " " + j) //Out:1 11 22 12 2
}

循环返回值

var res = for (i <- 1 to 10) yield {
    if (i % 2 == 0) {
        i
    }
}
print(res) //Vector((), 2, (), 4, (), 6, (), 8, (), 10)

解释说明：对1到10进行遍历，将每次遍历得到的i经过处理将结果放到集合Vector中