控制复杂性是计算机编程的本质。-- Brian Kernigan
Scala继承体系结构设计非常巧妙，它没有特殊地对待「基本数据类型」，将万物视为对象。此外，Scala在顶层引入Any，它是所有类的父类；而在底层引入了Nothing，它是所有类的子类，整个系统的设计保持一致和完整。
Any
总体上，Scala的对象可分为两个类型：
- 引用类型(Reference Types)：继承自
AnyRef - 值类型(Value Types)：继承自
AnyVal
而Any则是AnyVal, AnyRef的父类。也就是说，Any是所有Scala类型的父类，它内置于Scala内部，由编译器实现。
元类
Class<T>的实例代表了T类型的元数据；对于每个T类型，在JVM运行时有且仅有一个Class<T>的实例存在。
在Scala里，要获取T类型的Class<T>实例，可以使用classOf的实用方法。
classOf[String]
其中，classOf定义在Predef之中，由Scala的编译器实现。
def classOf[T]: Class[T] = ???
强制转换
Scala并没有提供强制类型转换的特殊语法，它们是通过调用isInstanceOf/asInstanceOf方法实现。
if (obj.isInstanceOf[Point])
val other = obj.asInstanceOf[Point]
它们定义于Any之中，它们都具有一个类型参数。
class Any {
final def isInstanceOf[T]: Boolean = ???
final def asInstanceOf[T]: T = ???
}
相等性
Scala使用==/!=比较对象间的逻辑相等性，而使用eq/ne比较对象间的物理相等性。其中，Any中的==/!=方法使用equals实现，并处理了null值比较的情况。而Any中定义的equals默认使用eq比较对象间的物理相等性。也就是说，如果一个类未重写equals方法，==/!=方法比较对象间的物理相等性。
class Any {
final def !=(that: Any): Boolean = !(this == that)
final def ==(that: Any): Boolean =
if (null eq this) null eq that
else this equals that
def equals(that: Any): Boolean = this eq that
}
AnyRef
AnyRef是所有「引用类型」的根类，它等价于Object。引用类型要么引用new构造的实例，要么引用null值。
val s: String = null
对象一致性
AnyRef中定义了eq/ne，用于比较对象间的物理相等性。其中，
- 对于非
null的x: AnyRef,x eq null与null eq x都返回false； - 但是，对于
null eq null则返回true。
class AnyRef {
final def ne(that: AnyRef): Boolean = !(this eq that)
final def eq(that: AnyRef): Boolean =
(this, that) match {
case (null, null) => true
case (null, _) => false
case (_, null) => false
case _ => this same that
}
// same为编译器内部实现的，比较两个引用类型的物理相等性
private def same(that: AnyRef): Boolean = ???
}
Null
Null类型为所有引用类型的子类，其拥有唯一的实例：null。
package scala
abstract final class Null private extends AnyRef
AnyVal
AnyVal是所有「值类型」的根类，包括Unit, Bolean, Char, Byte, Short, Int, Long, Float, Double。
值类型的实例，由编译器将其映射为原生的基本数据类型，存取效率相当高效。但是，值类型不能使用new构造实例，也不能持有null值，而应该使用「字面值」直接初始化。
val MAX_NUM: Int = null // Error
Unit
Unit类型是一个特殊的值类型，它等价于Java中的void。它拥有唯一的实例：()，即0个元素的元组。
classOf[Unit] // Class[Unit] = void
().getClass // Class[Unit] = void
classTag[Unit] // scala.reflect.ClassTag[Unit] = Unit
classTag[Unit].runtimeClass // Class[_] = void
过程
返回值类型为Unit的函数常常称为「过程」。例如，Runnable中的run方法就是一个典型的过程。
trait Runnable {
def run(): Unit
}
按照惯例，run有可能产生副作用，为此run显式地声明了()。
区分Int, RichInt, Integer
探秘Int
Scala是一门纯的面向对象的程序设计语言，它没有特殊地对待原生的基本数据类型，例如int, short, long, char等。
1 + 2
它实际上是一个函数调用过程，等价于
1.+(2)
事实上，+方法定义在Int类中。
final abstract class Int private extends AnyVal {
def +(x: Int): Int = ???
...
}
为了提升效率，Int将映射为JVM中的int。
探秘RichInt
求取1至10的和，可以如此实现。
(1 to 10).sum
它等价于：
1.to(10).sum
但是，Int中并没有定义to方法，但1 to 10为什么能够工作呢？事实上，在Predef中定义了Int到RichInt的隐式转换。
object Predef {
implicit def intWrapper(x: Int) = new scala.runtime.RichInt(x)
...
}
而RichInt中刚好定义了一个to方法，它创建了一个Range.Inclusive类型的实例。
package scala.runtime
class RichInt {
def to(end: Int): Range.Inclusive = Range.inclusive(self, end)
...
}
RichInt是一个Int的富包装类型。这样的设计机制，不仅保持了Int的高效，而且也保证了RichInt良好的可扩展性。
探秘Integer
Integer是Int的包装器，它的实例分配于堆中。对于Scala，自动装箱和自动拆箱是通过隐式转换完成的。或者说，自动装箱和自动拆箱仅仅是隐式转换的一个应用场景而已。
object Predef {
...
implicit def int2Integer(x: Int) = Integer.valueOf(x)
implicit def Integer2int(x: Integer): Int = x.intValue
}
仿真Boolean
为了加深理解值类型的工作原理，这里自制仿真实现了一个Boolean，其行为等价于标准库的Boolean实现；但是，此处的Boolean实现采用了函数式的设计思维。
函数式结构
Boolean是一个典型的函数式的数据结构，true和false是Boolean的两个字面值。其中，eval相当于if-else表达式。
sealed trait Boolean {
def eval[T](t: => T, e: => T): T
}
object true extends Boolean {
def eval[T](t: => T, e: => T): T = t
}
object false extends Boolean {
def eval[T](t: => T, e: => T): T = e
}
短路求值
&&与&之间的差异在于前者拥有「短路求值」的特性，而后者没有；
sealed trait Boolean {
def eval[T](t: => T, e: => T): T
def &&(x: => Boolean): Boolean = eval(x, false)
def ||(x: => Boolean): Boolean = eval(true, x)
def unary_! : Boolean = eval(false, true)
def &(x: Boolean): Boolean = eval(x, false)
def |(x: Boolean): Boolean = eval(true, x)
def ^(x: Boolean): Boolean = eval(false, True)
}
相等性
对于两个Boolean实例，也可以通过eval实现==/!=的比较逻辑。
sealed trait Boolean {
...
def eval[T](t: => T, e: => T): T
def ==(x: Boolean): Boolean = eval(x, !x)
def !=(x: Boolean): Boolean = eval(!x, x)
}
Nothing
Nothing是一个特殊的类型，它处在继承层次的最底部，它是所有类的子类。虽然Nothing没有任何实例存在，但它在Scala的类型系统中扮演了重要的角色。
package scala
final abstract class Nothing extends Throwable
空类型
Nil继承自List[Nothing]，且为唯一的单键对象；因为List[+A]是协变的，所有对于任意的类型A，List[Nothing]都是List[A]的子类。
sealed abstract class List[+A]
final case class ::[A](head: A, tail: List[A]) extends List[A]
final case object Nil extends List[Nothing]
表示异常
Nothing继承自Throwable，它表示程序的异常终止。例如，Predef中定义的???占位方法，其返回值类型就是声明为Nothing。
object Predef {
def ??? : Nothing = throw new NotImplementedError
}
在实施
TDD实践过程中，为了快速编译通过，可以使用???表示占位实现。
