相对于java的类型系统，scala无疑要复杂的多!也正是这复杂多变的类型系统才让OOP和FP完美的融合在了一起！
Nothing:
如果直接在scala-library中搜索Nothing的话是找不到了，只能发现一个Nothing$的类（后面再说Nothing$和Nothing的关系）。要想看到Nothing.scala的源码需要去github上的scala源码中查找Nothing源码 可以看到在Nothing.scala中只是定义了一个sealed trait：
package scala /** `Nothing` is - together with [[scala.Null]] - at the bottom of Scala's type hierarchy.
*
* `Nothing` is a subtype of every other type (including [[scala.Null]]); there exist
* ''no instances'' of this type. Although type `Nothing` is uninhabited, it is
* nevertheless useful in several ways. For instance, the Scala library defines a value
* [[scala.collection.immutable.Nil]] of type `List[Nothing]`. Because lists are covariant in Scala,
* this makes [[scala.collection.immutable.Nil]] an instance of `List[T]`, for any element of type `T`.
*
* Another usage for Nothing is the return type for methods which never return normally.
* One example is method error in [[scala.sys]], which always throws an exception.
*/
sealed trait Nothing
在这里，Nothing没有任何实例，其类似于java中的标示性接口（如：Serializable，用来标识该该类可以进行序列化），只是用来标识一个空类型。根据官方注释可以看出来Nothing用来标识no instances类型，该类型是其它所有类型的子类型。官方注释中给了如下两个用途：
1、用来当做Nil的类型List[Nothing]
case object Nil extends List[Nothing] {...}Nil表示一个空的list，与list中的元素类型无关，他可以同时表示List[任意类型]的空集合。也即是Nil可以同时表示List[Int]类型的空集合和List[String]类型的空集合。那么考虑一下Nil:List[?],这里的“？”应该为什么类型呢？也即是“？”应该为Int、String....所有类型的子类型（List集合为协变的）。因此这里引入了Nothing类型作为所有类型的子类型。这样Nil:List[Nothing]就可以完美实现上述需求。
2、表示非正常类型的返回值类型
例如Nil中的两个方法:
override def head: Nothing = throw new NoSuchElementException("head of empty list")
override def tail: List[Nothing] = throw new UnsupportedOperationException("tail of empty list")Nil为空List，所以调用head和tail应该返回Nothing和List[Nothing]的实例。但是Nothing是没有实例的，这里就直接抛出Exception。所以这里就使用Nothig来表示throw .... 非正常返回的类型。非正常即发生了错误没有返回任何对象，连Unit都没有，用Nothing类表示确实也挺合适。
明白了Nothing的表示的含义以及Nothing的应用场景，那么，Nothing是如何工作的呢？Nothing和Nothing$之间又有什么关系呢？
分别对Nothing.scala和Nothing$.scala进行编译和反编译：
Nothing.scala
Nothing$.scala
编译之后的文件名
根据上面的结果来看，Nothing.scala编译之后是一个接口类型：
public abstract interface Nothing {} 而Nothing$.scala编译之后是一个抽象类：
public abstract class Nothing$ extends Throwable{}从这里看两者没有任何关系。但是在Nothign$.scala的源码中有一段注释：
package scala
package runtime
/**
* Dummy class which exist only to satisfy the JVM. 虚拟类，只存在于JVM中
* It corresponds to `scala.Nothing`. 它对应scala.Nothing
* If such type appears in method signatures, it is erased to this one. 如果该Nothing出现在方法签名中则将会被抹掉,然后替换为Nothing$
*/
sealed abstract class Nothing$ extends Throwable
这里阐明了Nothing$的作用，也即是代码中如果出现Nothing类型的时候，在load到JVM运行的时候将会把Nothing替换为Nothing$类型。也即在JVM之外以Nothing的身份进行显示，在JVM中以Nothing$的身份进行显示，两者表示同一个含义。
这样解释也满足了Nothing可以当做 throw new XXXXXException("head of empty list")的类型使用的原因，即： Nothing$ extends Throwable.
Null:
Null.scala的源码和Nothing.scala的源码在同一个包中存在着Null.scala源码 。对比一下两者：
Null有唯一的实例null Nothing没有任何实例
Null是所有引用类型（AnyRef）的子类型 Nothing是所有类型的子类型 因此=> Nothing是Null 的子类型
除了上面的两点区别之外，Null和Nothing几乎一致
Null.scala 源码：
package scala /** `Null` is - together with [[scala.Nothing]] - at the bottom of the Scala type hierarchy.
*
* `Null` is a subtype of all reference types; its only instance is the `null` reference.
* Since `Null` is not a subtype of value types, `null` is not a member of any such type. For instance,
* it is not possible to assign `null` to a variable of type [[scala.Int]].
*/
sealed trait Null
注释中也明确说明Null是所有引用类型的子类型，只有唯一个一个实例null。trait Null 说明其实一个类型，那么就可以用该类型定义字段：val myNull:Null=null
那么注释中说Null有唯一的一个实例，那么我们new一个Null如何呢？
这里提示Null是一个abstract抽象类，可源码中定义的Null是一个trait,那么这里在运行的时候为何会提示Null is abstract呢？其次在和Nothing$.scala 旁边同样存在一个Null$.scala，这个类和Null.scala又有什么关系呢？
正如你想象的那样，Null$.scala正是Null在JVM中的另一种身份。我们看一下Null$.scala 的源码：
package scala
package runtime
/**
* Dummy class which exist only to satisfy the JVM. 该类为虚拟类，只存在JVM
* It corresponds to `scala.Null`. 它对应着scala.Null
* If such type appears in method signatures, it is erased to this one. 如果Null出现在方法签名中则用Null$去替换
* A private constructor ensures that Java code can't create subclasses. private构造方法确保不会被创建其它实例
* The only value of type Null$ should be null 唯一个实例及时null
*/
sealed abstract class Null$ private ()
这里明确指出Null将会被Null$替换，那么在运行的时候Null便为Null$类型！原来上面提示Null is abstract是这个原因！！我们再进一步确认一下，查看一下Null$.scala 进行编译看编译之后的代码:
对Null$.scala进行编译然后反编译结果：
（注意：在javap查看代码的时候如果是private 构造参数则不会显示处理，如果是public则会直接显示处理，上面没有显示private Null$()正说明Null$的构造参数正是private类型的）
到这里就完全就明白了，Null在运行期间被替换了Null$.
Unit:
在解释Unit之前需要分析一下函数的返回值有几种可能性！
1、正常返回了数据，例如 def demo01():Int=10 def demo02():String="hello"
2、方法发生异常，没有执行结束，未进行返回操作。例如 def demo02():Nothing=throw new NoSuchElementException("head of empty list")
3、方法返回了一个类型X的实例，该类型X表示 “没有返回值”的类型。这里有些绕，要仔细理解“没有返回值”和“没有返回值类型”。而这里的X即是Unit,而返回的那个实例即()，在java中表示未void。例如： def demo03():Unit={println("hello")}
对于1很好理解，返回什么就接受什么类型。对于2便是上面说的Nothing类型，没有进行返回操作；对于3是有返回的，只是返回的内容表示“没有返回值”的类型。
在源码中很好的解释了Unit的作用：
/** `Unit` is a subtype of [[scala.AnyVal]]. There is only one value of type
* `Unit`, `()`, and it is not represented by any object in the underlying
* runtime system. A method with return type `Unit` is analogous to a Java
* method which is declared `void`.
*/
final abstract class Unit private extends AnyVal {
// Provide a more specific return type for Scaladoc
override def getClass(): Class[Unit] = ???
}
根据注释可以看出，Unit是所有AnyVal 的子类（注意区别Nothing）,只有一个唯一的Value（注意这里是Value依旧是实例/对象）。如果方法的返回值类型为Unit,则类似于java中void。
在Unit的伴生对象中则揭开了Unit和void的关系：
object Unit extends AnyValCompanion {
/** Transform a value type into a boxed reference type.
*
* @param x the Unit to be boxed
* @return a scala.runtime.BoxedUnit offering `x` as its underlying value.
*/
def box(x: Unit): scala.runtime.BoxedUnit = scala.runtime.BoxedUnit.UNIT
/** Transform a boxed type into a value type. Note that this
* method is not typesafe: it accepts any Object, but will throw
* an exception if the argument is not a scala.runtime.BoxedUnit.
*
* @param x the scala.runtime.BoxedUnit to be unboxed.
* @throws ClassCastException if the argument is not a scala.runtime.BoxedUnit
* @return the Unit value ()
*/
def unbox(x: java.lang.Object): Unit = x.asInstanceOf[scala.runtime.BoxedUnit]
/** The String representation of the scala.Unit companion object. */
override def toString = "object scala.Unit"
}请注意box()和unbox()方法，该方法是对数值类型进行装箱和拆箱操作，scala中所有的数值型类型类中都有这两种方法，主要用来数值型向java 数值的封装型转化，例如：int->Integer float->Float
那么Unit中的box()和unbox()也是进行拆装箱操作了，我们看到在Unit的unbox中把java.lang.Object类型转换为一个BoxeUnit类型的数据，那么这个BoxedUnit是什么类型呢？我们打开源码看一下：
package scala.runtime;
public final class BoxedUnit implements java.io.Serializable {
private static final long serialVersionUID = 8405543498931817370L;
public final static BoxedUnit UNIT = new BoxedUnit();
public final static Class<Void> TYPE = java.lang.Void.TYPE;
private Object readResolve() { return UNIT; }
private BoxedUnit() { }
public boolean equals(java.lang.Object other) {return this == other;}
public int hashCode() { return 0;}
public String toString() {return "()";}
}
可以看到其TYPE值直接指向了java的void: public final static Class<Void> TYPE = java.lang.Void.TYPE;
看来scala只是使用Unit对java中的void进行了包装，用Unit来表示void的类型，用BoxedUnit的单例对象来表示那个唯一的void，也即是Unit中的“()”。到这里才明白Unit是没有任何实例的，它只是起一个类型的作用，而那个“()”也只是BoxedUnit的单例对象toSting的输出内容而已。
None:
在说None之前需要了解Option类型。Option类型是对值进行封装，根据值是否为null来返回Some(value)或者None:
def apply[A](x: A): Option[A] = if (x == null) None else Some(x)
Option的apply()方法可以返回None/Some可知None或Some必定是Option的子类了。看三者的定义：
sealed abstract class Option[+A] extends Product with Serializable {}//注意sealed 关键字
//class
final case class Some[+A](value: A) extends Option[A] {
def isEmpty = false
def get = value
}
//Object
case object None extends Option[Nothing] {
def isEmpty = true
def get = throw new NoSuchElementException("None.get")
}Option[+A]前面有sealed 关键字，则Option[+A]的所有子类必须在同一个文件中定义。因此Option只有Some和None两个子类。注意上面对Some和None的定义，Some是Class，而None是Object。class容易理解，是可以new实例的，而Object类型在编译之后构造方法是private，无法在外部生成实例对象，而其中的方法编译之后变为static的静态方法，可以通过类名直接调用。另外，在对Object进行编译的时候会同时生成一个XXXX$.class的文件，该类是一个单例类，内部会构造一个 public static XXXX$ MODULE$; 单例对象。None也同样如此：
因此我们平时所使用的None其实就是这个public static scala.None$ MODULE$; 单例对象。在应用层面上我们只需要知道None就是一个Option[Nothing]类型的对象，调用get()方法将会抛出NoSuchElementException("None.get")异常,其存在的目的是为了表面java中的NullPointerException()的发生。
null:
null 就很容易理解了和java中的null是同一个null。一般在scala中不直接使用null！
Nil：
看一下源码：
case object Nil extends List[Nothing] {....}根据object便可知Nil是一个单例对象，必定存在一个Nil$.class，在解压的scala-library中找到Nil$.class进行反编译可以找到Nil$的单例对象：
可以看到 class scala.collection.immutable.Nil$ extends scala.collection.immutable.List<scala.runtime.Nothing$> ，说明Nil是List[Nothing]的子类。而在源码中的方法则直接表明了Nil的性质：一个没有元素的List集合：
override def isEmpty = true//集合为空
override def head: Nothing = throw new NoSuchElementException("head of empty list")//抛出NoSuchElementException异常
override def tail: List[Nothing] = throw new UnsupportedOperationException("tail of empty list")//抛出UnsupportedOperationException异常
=========================================
原文链接：scala(一)Nothing、Null、Unit、None 、null 、Nil理解 转载请注明出处！
=========================================
-----end