1.Scala的数值类型

Scala的数值类型与Java类似，他们的范围与Java也是一致的。与Java不同的是，他们都是对象，是相应的数值类的实例。Scala通过富包装（Rich Wrapper）类给这些数值类型提供了强大的支持。

1.1.数值类型

Scala的数值类型和取值范围，见下表。

• Boolean: true 或者 false
• Byte: 8位, 有符号（2^-7 ~ 2⁷ - 1)
• Short: 16位, 有符号 （2^-15 ~ 2¹⁵ - 1)
• Int: 32位, 有符号 （2^-31 ~ 2³¹ - 1)
• Long: 64位, 有符号 （2^-63 ~ 2⁶³ - 1)
• Char: 16位, 无符号 （0 ~ 2¹⁶ - 1)
• Float: 32位, 单精度浮点数
• Double: 64位, 双精度浮点数

你可以像Java中一样使用这些类型。不过，实际上，Scala的类型系统与Java或其他语言，如C#或Java，不太一样，在Scala中，基本类型也是class，比如，Int类型，来自scala.Int，每一个数字，都是scala.Int的一个实例。 统一的类型系统，即原始类型与类的统一，是Scala的一大特点，这一特点让Scala比Java和C#等语言更加面向对象。

请注意
数值类型都被定义为abstract和final的，这意味着，不能通过new获得值类型的实例。创建它们的实例只能通过文本（Literal）。

1.2.装箱（Boxing）和拆箱（Unboxing）

熟悉Java或C#等语言的读者会知道，装箱是指将原始类型转换成引用类型（对象），用于需要对象的操作，而拆箱，则是把对象转换成原始类型，用于需要原始类型的场景。

由于数值类型本身已经是类对象，因此Scala里不需要装箱（boxing）和拆箱（unboxing）操作。
当然，Scala代码最终会运行在JVM上，所以实际上，始终会有装箱成Scala类对象，和拆箱成Java原始值类型的操作，但是这些操作是透明的，程序员不需要关心（实际上，这是由定义在Predef中的隐式转换完成的）。

1.3.富包装类（Rich Wrapper）

如上所述，你可以像在Java中一样使用基本类型，不过，Scala实际上提供了非常多的方法给基本类型。这些方法在富包装（Rich Wrapper）里，比如，Int对应的是scala.runtime.RichInt。每一个基本类型都有一个相对应的富包装类。
基本类型，在必要的时候通过隐式转换转换为对应的富包装类，从而可调用富包装类提供的方法。

隐式转换是Scala相当重要的技术，后续文章将会介绍。
下面我们写几行code看一下RichInt的强大功能。

val n1 = 2 max 3
println("2 max 3 = " + n1)

val n2 = -1.abs
println("-1.abs = " + n2)

val n3 = 1 to 5
println("1 to 5 = " + n3)

val n4 = 1.isValidChar
println("1.isValidChar = " + n4)

val n5 = -1.isValidChar
println("-1.isValidChar = " + n5)

2.Scala的字符串（String）

String是非常常用的类型，本质上其实是一系列的Char，但是由于它太常用，在很多方面都有特殊处理，在大多数编程语言里都会被单独列出。

Scala里的String是直接借用了Java的String，也就是说，String只是java.lang.String的一个别名，源代码类似于：

type String = java.lang.String

不过，由于String实际是一系列Char的不可变的集合，Scala中大部分针对集合的操作，都可以用于String，具体来说，String的这些方法存在于类scala.collection.immutable.StringOps中。 由于String在需要时能隐式转换为StringOps，因此不需要任何额外的转换，String就可以使用这些方法。如下所示。

val str = "Hello"
val r1 = str.drop(2)  //"llo"
println("\"Hello\".drop(2) = " + r1)

val r2 = str.dropRight(2) //"Hel"
println("\"Hello\".dropRight(2) = " + r2)

val r3 = str.filter( _ != ‘l‘) //"Heo"
println("\"Hello\".filter( _ != ‘l‘) = " + r3)

val r4 = str.intersect("world")  //"lo"
println("\"Hello\".intersect(\"world\") = " + r4)

与Java或C#一样，String是不可变的，对String进行操作，会得到新的String实例。因此在需要频繁操作String的情况下，请使用StringBuilder。

val builder = new StringBuilder
builder.append("Hello")
builder.append(", world")
builder += ‘!‘
builder.insert(0,"Me: ")
println(builder)   //Me: Hello, world!

3.Scala的类层级

3.1.Scala的统一类型

Scala中，所有的值都是类对象，而所有的类，包括值类型，都最终继承自一个统一的根类型Any。统一类型，是Scala的又一大特点。更特别的是，Scala中还定义了几个底层类（Bottom Class），比如Null和Nothing。类层级结构图如下所示。

3.1.1.顶层类Any

Any是最顶层的类，这意味着，所有的类都是Any的子类型，都可以调用Any类的方法。顶层类Any提供了如下方法，Scala的任意对象都可以调用这些方法。

final def ==(that: Any): Boolean
final def !=(that: Any): Boolean
def equals(that: Any): Boolean
def ##: Int
def hashCode: Int
def toString: String

请注意
以上方法中，== , != 与Java中是有区别的。Scala里，==永远跟equals是一样的，!=则是其否定。==与!=是final的，因此不能被重载。
要比较对象的引用，需使用AnyRef的eq方法。

3.1.2.底层类Null和Nothing

Null是所有引用类型的子类型，而Nothing是所有类型的子类型。Null类只有一个实例对象，null，类似于Java中的null引用。
由于Null是所有引用类型的子类型，这意味着，null可以赋值给任意引用类型，但是不能赋值给值类型。

也许你要问，那么是不是可以将Nothing类的实例对象赋值给值类型。答案是不可以，因为Nothing类没有实例，一个也没有。没有实例的Nothing类有什么作用呢？

Nothing，可以作为没有正常返回值的方法的返回类型，非常直观的告诉你这个方法不会正常返回，而且由于Nothing是其他任意类型的子类，他还能跟要求返回值的方法兼容。
这句话不是很好理解，我们用个例子来说明。scala.sys有两个方法error和exit，源代码如下：

def error(message: String): Nothing = throw new RuntimeException(message)

def exit(): Nothing = exit(0)

通过返回类型Nothing，我们就知道，error方法和exit方法不会正常返回。但是我们在调用他们的时候，可以跟所要求的返回值兼容，比如：

def divide(x: Int, y: Int): Int = {
  if (y == 0) error("divide by zero")
  else x / y
}

上面的divide方法要求返回一个Int值，但是如果出错，Nothing也是可以接受的。

另一个用处是在有泛型的地方，由于Scala支持协变（如果不理解协变，没关系），Nothing在必要的时候可以代替其他的类型。 比如List[Nothing]就可以当做任意类型的List[T]使用。恰好，类型List[Nothing]，有一个特别的实例，Nil。所以Nil可以当做任意List[T]的实例使用。

3.1.3.Unit类型

在类层级结构图里能看到，在AnyVal的子类型里，有一个特别的类型，Unit。Unit类型用来标识过程，也就是没有明确返回值的函数。 由此可见，Unit类似于Java里的void。Unit只有一个实例，()，这个实例也没有实质的意义。

参考文献：

http://meetfp.com/zh/scala-basic/class-hierarchy