首先需要Scala开发环境的搭建，网上自己找教程。
声明常量与变量
val foo = 0 // 常量
var bar = 0 // 变量
在Scala中，更加鼓励使用val来进行声明，也就是推荐使用常量。在大部分时候不需要分号，看自己便好…虽然是强静态类型的语言，但是却并没有写出类型——这就是类型推断。
也可以指定类型：
val spark: String = "Hello Scala"
多个的同时声明：
val xInt, yInt = 100 // xInt, yInt都声明为100
常用类型
与Java类似，Scala中也有表示数值类型的类，但是Scala不区分基本类型和引用类型。也就是说Scala中一切都是对象了吧。
Scala对Java中的数值类型的功能添加了许多功能上的强化，这其中涉及了隐式转换。比如，String类型转换成StringOps类型。还有RichInt、RichDouble等对应Int、Double类型。至于有什么新加的方法，可以查看Scala API。
操作符
算数操作符应该与预期中的没有什么差异，因为如果有差异用起来就有麻烦了。但算数操作符事实上是方法。
a + b 相当于 a.+(b)
对于带有一个隐式参数和一个显式参数的方法来说，通常都可以这么简化。如：
1.to(10) 这会产生一个1-10的Range实例，相当于 1 to 10
两种风格任君选择。
Scala没有提供++和–（别认为我打错了，这里是有两个-号的）这两个其他语言中很常见常用的操作符，理由是：不值得为少按一个键而额外增加一个特例。
Scala中可以对操作符进行重载。
调用函数和方法
函数（function）和方法（method）
引入相应的包后，使用函数很简单，不需要从某个类中调用静态方法。
math.sqrt(2) 等同于 scala.math.sqrt(2) // 以scala.开头的包名，都可以省去该前缀
Scala中没有静态方法，但是有单例对象和伴生对象之类的概念可以实现差不多的特性，这些估计到后面会细说。
BigInt.probablePrime(100, util.Random)
通常，使用没有参数，且不改变当前对象的方法时，不带圆括号。
apply方法
s是一个字符串，而 s(4) 将会返回该字符串中第4个字符。在使用形如 s(4) 这种，类似于函数调用的语法时，实际上是调用了 apply() 方法。也就是说， s(4) 等于 s.apply(4)
两个容易混淆的概念——表达式（expression）和语句（statement）。表达式有值，而语句没有值只执行操作。
要说起这一点的原因是，Scala中，几乎所有构造出来的语法结构都有值，也就是表达式。这可以使程序更加精简易读。
举例，if表达式是有值的；语句块也是有值的，是最后一个表达式的值。
而对应Java中的void，Scala中有一个类型Unit，用来表示“无有用值”（void表示没有值，这里还是有差别的）。
条件表达式
if/else表达式在Scala中是有值的，除开这一点，与Java等语言没有什么差别。而有值所带来的效果，可以是下面这样子的：
val s = if (x > 0) 1 else -1
// 与上等效的另一种写法
if (x > 0) s = 1 else s = -1
第一种写法可以用来初始化一个val，而第二种则要求s必须是var。前面也说了，Scala中更鼓励使用val。
同时，这样的条件表达式，还可以实现比三目操作符 ? : 更加灵活的功能。
如果在if和else两边的类型是不同的，比如：
if (x > 0) "positive" else -1
这时返回的类型将会是两个分支类型的公共超类型（这里是String和Int的公共超类型Any）。
如果没有else部分，那么if表达式有可能不返回值，这时候就需要前面提到的Unit类型，写做()。
if (x > 0) 1
// 这相当于else部分返回Unit类型，相当于下面的写法
if (x > 0) 1 else ()
语句终止
分号不是必须的，但是使用它们不会带来坏处。
能根据上下文判断出语句结尾的地方，都不需要使用分号。怎么判断是否语句结尾，以后在编码过程中会慢慢积累起感觉的。
如果需要在单行中写多个语句，那么就需要使用分号了。而在写一个较长的语句时，如果需要分行写，要确保前面的行尾需要以不能用来语句结尾的符号来结束。比如说像是下面的操作符：
a = s0 + (v - v0) * t + // +说明了这里不是语句结束哦
0.5 + (a - a0) * t * t
// 下面这种写法就会出问题了
a = s0 + (v - v0) * t
+ 0.5 + (a - a0) * t * t
这里还可以发现的是，Scala推荐使用两个空格来缩进。
由于判断语句终止的需要，Scala程序员更倾向于使用Kernighan & Ritchie风格的花括号（也就是Java中推荐的方法）：
if (n > 0) {
r = r * n
n -= 1
}
块表达式和赋值
Scala中，{ }包含一系列的表达式，而且{ }最后返回的也是一个表达式——最后一个表达式。
而赋值语句的值，是Unit类型的。这也大体上决定了在Java和C++中的 x = y = 1 会出现的赋值语句，几乎不可能出现在Scala中。
输入和输出
输入函数： readLine()、 readInt()等，用来从控制台Console中读取输入。
而输出部分，则是很常见的 print()、 println()、 printf()。
循环
看看Scala中的for循环：
for (i <- expression) // 让i遍历表达式的所有值，遍历的执行取决于表达式的类型
// 例子
for (i <- 1 to n) // 遍历1到n
for (i <- 0 util s.length) // 遍历0到s.length-1
// 遍历求和
var sum = 0
for (ch <- "Hello") sum += ch
事实上，Scala中更多是使用函数式而不是指令式的风格来遍历等操作。后面会见到的。
高级for循环和for推导式
在一个for循环中使用多个“generator”（生成器）：
for (i <- 1 to 3; j <- 1 to 3) print ((10 * i +j) + " "
// 结果：11 12 13 21 22 23 31 32 33
在for循环中使用“filter ”（过滤器，守卫）来过滤一部分不符合条件的枚举情况：
for (i <- 1 to 3; j <- 1 to 3 if i != j) print ((10 * i + j) + " ")
// 结果：12 13 21 23 31 32
可以使用多个filter，中间需要使用分号分隔。
可以在for表达式中使用任意多的定义，引入在循环中使用变量：
for (i <- 1 to 3; from = 4 - i; j <- from to 3) print ((10 * i + j) + " ")
// 结果：13 22 23 31 32 33
如果for表达式的循环体是以yield关键词开始的，那么该循环会构造出一个集合，这被称为for推导式。推导式生成的集合与第一个generator是类型兼容的。
for (c <- "Hello"; i <- 0 to 1) yield (c + i).toChar
// 生成"HIeflmlmop"
还可以将for表达式的小括号换成花括号，这样可以省去写分号的功夫。
for表达式内容不少，而且这里也不是全部。在《Programming in Scala》中，还有一些高级的讨论，这里就先略了，先入个门。
函数
在Java中并没有函数这个概念，函数的功能是用静态方法来实现的。
函数的定义：
def 函数名(指明类型的参数): 可选的返回值类型 = 函数体
def fac(n: Int) = {
var r = 1
for (i <- 1 to n) r = r * i
r
}
只要函数不是递归的，就不需要给出函数的返回值类型（因为有类型推断）。一个递归的函数需要如下写：
def fac(n: Int): Int = if (n <= 0) 1 else n * fac(n - 1)
在Scala中，并不时常使用return来返回值。
默认参数和带名参数
Java里似乎没有默认参数和带名参数，至少我从来没有使用过。但记得C++是有的。
def decorate(str: String, left: String = "[", right: String = "]") =
left + str + right
上面的函数有两个带有默认值的参数left和right。如果不给出这两个参数，调用这个函数，会使用默认值。也可以给出自己的参数来替代默认的。
参数个数不够时，将会从后往前使用默认参数。
调用函数时，如果指定参数名，那么参数可以不按照参数列表的顺序来：
decorate("Hello", right = "]<<<")
从上面还可以知道，可以混用未命名参数和带名参数。
变长参数
def sum(args: Int*) = {
var result = 0
for( arg <- args) result += arg
result
}
星号表示可接受变长参数列表。函数实际得到的参数是Seq类型的。
但是在调用变长参数函数时，并不能直接使用Seq类型的参数。要将一个Seq类型打散成单个的参数序列，使用 : _*。
def recursiveSum(args: Int*) = {
if (args.length == 0) 0
else args.head + recursiveSum(args.tail: _*)
}
过程（procedure)
过程的定义与函数很类似。函数体在花括号中，而且花括号前没有=号，返回值是Unit类型的，这就是过程了。（也可以写出=号，并且写明返回值是Unit类型来定义过程。）
通常，过程没有返回值，只是为了副作用而调用一个过程。
懒值
当val被声明为lazy时，初始化会被推迟到首次对其取值时。
lazy val words = io.Source.fromFile("/usr/share/dict/words").mkString
如果程序一直不妨问words，那么Scala也不会去打开那个文件。文件是在实际第一次使用words时被打开的。
懒值对开销较大的初始化语句十分有用，可以应对一些初始化问题比如循环依赖。还是开发懒数据结构的基础。
可以将懒值当成是介于val和def的中间状态：
- val在被定义时即被取值
- lazy val在首次使用时被取值
- def在每次使用时取值
异常
Scala中异常机制与Java和C++中一样。但Scala中并没有受检异常，也就是不需要说明函数方法可能会抛出什么异常。
使用throw来抛出一个异常。throw表达式的类型是Nothing。
捕获异常：
try {
process(new URL("http://horstmann.com/fred-tiny.gif"))
} catch {
case _: => MalformedURLException => println("Bad URL: " + url)
case ex: IOException => ex.printStackTrace()
}
如果不需要使用捕获的异常对象，使用_来代替变量名（_是Scala中的通配符）。
同时也有try/finally语句，通常用来清理。可以组合成try/catch/finally语句
fRom: http://nerd-is.in/2013-08/scala-learning-control-structures-and-functions/