Scala继承体系结构

控制复杂性是计算机编程的本质。-- Brian Kernigan

Scala继承体系结构设计非常巧妙，它没有特殊地对待「基本数据类型」，将万物视为对象。此外，Scala在顶层引入Any，它是所有类的父类；而在底层引入了Nothing，它是所有类的子类，整个系统的设计保持一致和完整。

Scala继承体系结构

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实践过程中，为了快速编译通过，可以使用???表示占位实现。