Scala继承体系结构

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

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

Scala继承体系结构_第1张图片
Scala继承体系结构

Any

总体上,Scala的对象可分为两个类型:

  • 引用类型(Reference Types):继承自AnyRef
  • 值类型(Value Types):继承自AnyVal

Any则是AnyVal, AnyRef的父类。也就是说,Any是所有Scala类型的父类,它内置于Scala内部,由编译器实现。

元类

Class的实例代表了T类型的元数据;对于每个T类型,在JVM运行时有且仅有一个Class的实例存在。

Scala里,要获取T类型的Class实例,可以使用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,用于比较对象间的物理相等性。其中,

  • 对于非nullx: AnyRef, x eq nullnull 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

求取110的和,可以如此实现。

(1 to 10).sum

它等价于:

1.to(10).sum

但是,Int中并没有定义to方法,但1 to 10为什么能够工作呢?事实上,在Predef中定义了IntRichInt的隐式转换。

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

IntegerInt的包装器,它的实例分配于堆中。对于Scala,自动装箱和自动拆箱是通过隐式转换完成的。或者说,自动装箱和自动拆箱仅仅是隐式转换的一个应用场景而已。

object Predef {
  ...
  implicit def int2Integer(x: Int) = Integer.valueOf(x)
  implicit def Integer2int(x: Integer): Int = x.intValue
}

仿真Boolean

为了加深理解值类型的工作原理,这里自制仿真实现了一个Boolean,其行为等价于标准库的Boolean实现;但是,此处的Boolean实现采用了函数式的设计思维。

函数式结构

Boolean是一个典型的函数式的数据结构,truefalseBoolean的两个字面值。其中,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]是协变的,所有对于任意的类型AList[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实践过程中,为了快速编译通过,可以使用???表示占位实现。

你可能感兴趣的:(Scala继承体系结构)