Java关键字
Java 一共有 50 个关键字（keywords），其中有 2 个是保留字，目前还不曾用到：goto 和 const。true、false 和 null 看起来很像关键字，但实际上只是字面量而已。本文粗略的把true、false 和 null也看做Java关键字，认为Java一共有53个关键字。下面是大致归类的Java关键字列表：
- assert
- boolean, byte, short, char, int, long, float, double, void
- package, import, class, interface, enum, implements, extends
- public, protected, private, abstract, static, final, volatile, transient, synchronized, strictfp, native
- try, catch, finally, throw, throws
- if, else, do, while, for, switch, case, default, break, continue, return
- super, this
- new, instanceof
- const, goto
- true, false, null
Scala关键字
Scala只有 39 个关键字，下面是大致归类的 Scala 关键字列表：
- package, import, class, object, trait, extends, with, type, forSome
- private, protected, abstract, sealed, final, implicit, lazy, override
- try, catch, finally, throw
- if, else, match, case, do, while, for, return, yield
- def, val, var
- this, super
- new
- true, false, null
对比 Java 关键字 与 Scala 关键字
Java 和 Scala 共有的关键字
Java 和 Scala 共有的关键字，在两个语言里的含义也基本相同。只有一个例外：case。
在 Java 中，case 主要用在 switch-case 语句里。
在 Scala 中，没有switch-case语句，case 关键字主要用来定义 case 类和进行模式匹配。
只有 Java 才用到的关键字
共有 28 个Java关键字没有被 Scala 采用，但 Scala 也是要运行在JVM上的，所以下面来看一下这 28 个关键字所表达的含义是如何在 Scala 里实现的。
-
assert
scala.Predef定义了assert()方法，如下所示：
object Predef {
@elidable(ASSERTION)
def assert(assertion: Boolean) {
if (!assertion)
throw new java.lang.AssertionError("assertion failed")
}
@elidable(ASSERTION) @inline
final def assert(assertion: Boolean, message: => Any) {
if (!assertion)
throw new java.lang.AssertionError("assertion failed: "+ message)
}
}
-
boolean, byte, char, short, int, long, float, double
Scala 在 Java 的基础上迈出了一大步，从语法层面彻底消灭了基本类型，也就是说，一切皆是对象，Java 中所有的基本类型在 Scala 中都有相应的类：Boolean、Byte、Char、Short、Int、Long、Float和Double。具体请看这篇文章。
-
void
和 primitive 类型类似，Scala 使用了更加面向对象的方式来表达 void：Unit类。具体请看这篇文章。
-
interface和implements
Scala 用 Trait 取代了接口，具体请看这篇文章。
-
static
Scala 没有 static 概念，取而代之的是单例对象。具体请看这篇文章。
-
public
在 Scala 里，类、方法、字段等，默认就是 public，而且 Scala 也不允许将它们显式设置为 public，所以 public 这个单词没有任何特殊含义，可以自由使用。
-
const 和 goto
在 Scala 中，const 和 goto 不再是保留字，可以自由使用。
-
throws
Scala 抛弃了 Checked Exception，以及 throws 关键字。在 Scala 里，借用了模式匹配的思想来做异常的匹配，因此，在 catch 的代码里，是一系列 case 字句，如下例所示：
object Test {
def main(args: Array[String]) {
try {
val f = new FileReader("input.txt")
} catch {
case ex: FileNotFoundException =>{
println("Missing file exception")
}
case ex: IOException => {
println("IO Exception")
}
}
}
}
-
native、transient、volatile和strictfp
取代这4个关键字的，是4个注解：@native、@transient、@volatile 和 @strictfp。下面是示例代码：
@transient var t = 1
@volatile var v = 1
@strictfp
def f() = {}
@native
def n(x: Int): Int;
-
synchronized
Scala 提供了 synchronized 方法，用起来几乎和 Java 的 synchronized 关键字一样：
def sync() = {
this.synchronized {
val x = 2
}
}
但实际上并没有什么 synchronized 方法，反编译之后，上面的 Scala 代码和下面的 Java 代码一模一样：
public void sync() {
synchronized(this) {
...
}
}
-
instanceof
Scala 中取而代之的是 isInstanceOf[] 方法，代码如下所示：
def instanceof(arg: Any) = {
if (arg.isInstanceOf[String]) {
val str = arg.asInstanceOf[String]
}
}
-
enum
在Scala里，如果想定义枚举，应该继承 scala.Enumeration，比如下面这段代码：
object Color extends Enumeration {
val Red = Value
val Green = Value
val Blue = Value
}
-
break, continue, default, switch
如前所述，Scala 用模式匹配取代了 switch-case，从而解放了 switch 和 default 关键字。而 Scala 的 for 循环和 Java 的 for 循环也大相径庭。
Scala 虽然有 while 和 do-while 循环，但是里面不能用 break 和 continue，所以这两个关键字也解放了。
在 Scala 循环中需要实现 break 和 continue 功能代码如下：
// break
breakable(
for (i <- 0 until 10) {
println(i)
if (i == 5) {
break()
}
}
)
// continue
for (i <- 0 until 10) {
breakable {
if (i == 3 || i == 6) {
break
}
println(i)
}
}