认识Scala
Scala 是一门多范式（multi-paradigm）的编程语言，设计初衷是要集成面向对象编程和函数式编程的各种特性。
Scala 运行在Java虚拟机上，并兼容现有的Java程序。
Scala 源代码被编译成Java字节码，所以它可以运行于JVM之上，并可以调用现有的Java类库。
Scala特性
面向对象特性
Scala是一种纯面向对象的语言，每个值都是对象。对象的数据类型以及行为由类和特质描述。
类抽象机制的扩展有两种途径：一种途径是子类继承，另一种途径是灵活的混入机制。这两种途径能避免多重继承的种种问题。
函数式编程
Scala也是一种函数式语言，其函数也能当成值来使用。Scala提供了轻量级的语法用以定义匿名函数，支持高阶函数，允许嵌套多层函数，并支持柯里化。Scala的case class及其内置的模式匹配相当于函数式编程语言中常用的代数类型。
更进一步，程序员可以利用Scala的模式匹配，编写类似正则表达式的代码处理XML数据。
静态类型
Scala具备类型系统，通过编译时检查，保证代码的安全性和一致性。类型系统具体支持以下特性：
- 泛型类
- 协变和逆变
- 标注
- 类型参数的上下限约束
- 把类别和抽象类型作为对象成员
- 复合类型
- 引用自己时显式指定类型
- 视图
- 多态方法
扩展性
Scala的设计秉承一项事实，即在实践中，某个领域特定的应用程序开发往往需要特定于该领域的语言扩展。Scala提供了许多独特的语言机制，可以以库的形式轻易无缝添加新的语言结构：
任何方法可用作前缀或后缀操作符 可以根据预期类型自动构造闭包。
并发性
Scala使用Actor作为其并发模型，Actor是类似线程的实体，通过邮箱发收消息。Actor可以复用线程，因此可以在程序中可以使用数百万个Actor,而线程只能创建数千个。在2.10之后的版本中，使用Akka作为其默认Actor实现。
Scala语法
基本语法
Scala 基本语法需要注意以下几点：
-
区分大小写 - Scala是大小写敏感的，这意味着标识Hello 和 hello在Scala中会有不同的含义。
-
类名 - 对于所有的类名的第一个字母要大写。 如果需要使用几个单词来构成一个类的名称，每个单词的第一个字母要大写。 示例：class MyFirstScalaClass
-
方法名称 - 所有的方法名称的第一个字母用小写。 如果若干单词被用于构成方法的名称，则每个单词的第一个字母应大写。 示例：def myMethodName()
-
程序文件名 - 程序文件的名称应该与对象名称完全匹配(新版本不需要了，但建议保留这种习惯)。 保存文件时，应该保存它使用的对象名称（记住Scala是区分大小写），并追加”.scala”为文件扩展名。 （如果文件名和对象名称不匹配，程序将无法编译）。
-
示例: 假设”HelloWorld”是对象的名称。那么该文件应保存为’HelloWorld.scala”
-
def main(args: Array[String]) - Scala程序从main()方法开始处理，这是每一个Scala程序的强制程序入口部分。
基础语法
声明变量
- var：变量声明，程序运行过程中会发生改变的量
- val：常量声明，定义后不会改变的量，相当于Java中定义的final量
声明变量的语法：
var x = 1 //声明变量时候没有定义变量类型，程序运行时会根据赋值的内容动态的定义变量类型
var x:int = 1 //手动定义变量类型
var x, y = 100 // 多个变量的声明，x, y都声明为100
var arr = Array[Int](1,2,3)// 声明一个数组，包含1，2，3三个元素
var arr1 = new Array[Int](3)// 声明一个长度为3数组，里面包含的三个元素，是int的默认值（0）
val x = List(1,2,3,4) // 声明整型 List
val x = Set(1,3,5,7) //声明一个set
val x = (10, ->”scala”) // 或者 val x = (10, “scala”)，声明一个元组
val x = Map(“java” -> 1, “scala” -> 2) // 或者 val x = Map((“java” , 1),( “scala” , 2))，声明一个map
Scala 方法与函数
Scala 中的方法（method）跟 Java 的类似，方法是组成类的一部分。
Scala 中的函数（function）则是一个完整的对象，Scala 中的函数其实就是继承了 Trait 的类的对象。
Scala 中可以使用 val 、var接受定义的函数对象，def 语句定义方法。
- Scala 方法声明格式如下：
1
2
3
4
5
6
def functionName ([参数列表]) : [return type] = {
//方法主体
//return [expr]
//scala中return关键字可省略，如果不写默认最后一行是返回的对象
}
//如果你不写等于号和方法主体，那么方法会被隐式声明为抽象(abstract)，包含它的类型也是一个抽象类型。
列如：
1
2
3
4
5
6
7
8
9
def addInt( a:Int, b:Int ) : Int = {
var sum:Int = 0
sum = a + b
return sum
}
//如果方法没有返回值，可以返回为 Unit，这个类似于 Java 的 void,
def print( ) : Unit = {
println("Hello, Scala!")
}
- Scala 函数声明格式如下：
val f = ([参数列表]) => {
//方法主体
}
函数可以作为参数传递，而方法不行：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
object TestMain{
//定义一个方法，方法 m1 参数要求是一个函数，函数的参数必须是两个Int类型，返回值类型也是Int类型
def m1(f:(Int,Int) => Int) : Int = {
f(2,6)
}
//定义一个函数f1,参数是两个Int类型，返回值是一个Int类型
val f1 = (x:Int,y:Int) => x + y // 也可以使用简写：val f1 = (_:Int) + (_:Int )，第一个_表示第一个参数，一次类推
def main(args: Array[String]): Unit = {
//调用m1方法，并传入f1函数
val r1 = m1(f1)
println(r1)//运行结果为8
}
}
Scala if 表达式
scala if表达式与java的if表达式的格式基本相同，不同点在于scala的灵活性，下面代码就可以看出区别：
1
2
3
4
5
val flag = true
//条件判断并赋值，
val result=
if(flag) 100
else "一百"
while循环与for 表达式
- while循环
1 2 3
while( [boolean表达式]) { //循环体 } - do-while循环
1 2 3
do { //循环体 } while ([boolean表达式]) - for表达式
Scala的for表达式与java很相似，但是更加灵活，操作性更丰富，基本格式如下：
1 2 3
for( var x <- [范围]){ //循环体 }循环1到10：
1 2 3
for( a <- 1 to 10){ println( "Value of a: " + a ); }使用until关键字，循环1到9，不包含10：
1 2 3
for( a <- 1 until 10){ println( "Value of a: " + a ); }多区间循环：
1 2 3 4 5 6 7 8 9 10 11 12 13
for( a <- 1 to 3; b <- 1 to 3){ println( "[a" + a +"],[b" + b + "]"); } //输出结果： [a1],[b1] [a1],[b2] [a1],[b3] [a2],[b1] [a2],[b2] [a2],[b3] [a3],[b1] [a3],[b2] [a3],[b3]
循环对象：
1
2
3
4
val arr = Array[Int](1,2,3)
for(x <- arr) {
println(x)
}
使用yield关键字保存循环对象：
1
2
3
4
5
6
7
8
9
val arr = Array[Int](1,2,3)
val result = for(x <- arr) yield "我是" + x
for (r <- result) {
println(r)
}
//输出
我是1
我是2
我是3
Scala “_”下划线的用法
- 用于默认初始化
1
2
3
4
5
6
7
8
9
var num :Int =_
var str :String=_
def main(args: Array[String]): Unit = {
println(num)
println(str)
}
\\输出
0
null
-
导入包 Java中导包：
import math.*，Scala中是import math._，这里的_相当于* -
集合中使用（最典型，最常用）
1
2
3
4
5
6
object Sample {
def main (args: Array[String]){
val newArry= (1 to 10).map(_*2)
println(newArry)
}
}
这里的下划线代表了集合中的“某（this）”一个元素。这个用法很常见，在foreach等语句中也可以使用。
- 模式匹配
1 2 3 4 5 6 7 8 9 10 11 12
object Sample { def main (args: Array[String]){ val value="a" val result= value match{ case "a" => 1 case "b" => 2 case _ =>"result" //在这里的下划线相当于“others”的意思，就像Java switch语句中的“default” } println(result) } }
1
2
3
4
5
6
7
8
9
10
object Sample {
def main (args: Array[String]){
val value=Some("a")
val result= value match{
case Some(_) => 1
//被Some“包”起来的，说明Some里面是有值的，而不是None
case _ =>"result"
}
println(result)
}
- 函数中使用
1 2 3 4 5 6 7
object Sample { def main (args: Array[String]){ val set=setFunction(3.0,_:Double) println(set(7.1)) } def setFunction(parm1:Double,parm2:Double): Double = parm1+parm2 }这是Scala特有的“偏函数”用法。
