先回顾一下java的内部类

class Outter{

    public class Inner {}

    public void foo(Inner c){
        System.out.println(c);
    }
}

public class Main {
    public static void main(String[] args)throws Exception{
        Outter o1 = new Outter();
        Outter o2 = new Outter();
        Outter.Inner i1 = o1.new Inner();
        Outter.Inner i2 = o2.new Inner();
        o1.foo(i2);
    }
}

上面在Outter类内部定义了Inner类，在后边main里创建了两个Inner实例，注意创建内部类的时候

Outter.Inner i1 = o1.new Inner();

在用new创建内部类时，前边必须限定外部对象(内部类实例必须要访问到外部对象引用)：o1；如果是在 Outter类内部这个外部引用可以省略，它默认会用传递外部this引用。

class Outter {

    public class Inner{}

    public void test() {
        new Inner(); // 相当于this.new Inner(); 也可以写为Outter.this.new Inner();
    }
} 

同样的事情翻译为scala代码：

scala> class A { 
            class B; 
            def foo(b:B) = println(b) 
        }

scala> val a1 = new A
scala> val a2 = new A

scala> val b1 = new a1.B
scala> val b2 = new a2.B

在创建内部类的时候，语法上与java有所不同，不是 outter.new Inner() 而是 new outter.Inner()，看上去只是表象不同么？实际上，scala有很大差异，不同于java里 i1 和 i2 类型是相同的，否则 o1.foo(i2) 就不能执行了，scala里的 b1 和 b2 是不同的类型：

scala> a1.foo(b2)
<console>:12: error: type mismatch;
 found   : a2.B
 required: a1.B 

按照方法的提示: a1.foo方法接受的参数类型为：a1.B，而传入的b2 类型是 a2.B，两者不匹配。
验证一下：

scala> typeOf[a1.B] == typeOf[a2.B]
res2: Boolean = false

确实是不一样的类型，它跟外部的实例相关，那个foo方法参数类型B的写法是缩写，省略了路径：

def foo(b: B) // 相当于 this.B 或 A.this.B

这里要引入一个概念：路径依赖类型；比如上面的 A.this.B 就是一个路径依赖类型，B 前面的路径 A.this 随着不同的实例而不同，比如 a1 和 a2 就是两个不同的路径，所以a1.B 与 a2.B也是不同的类型。路径依赖类型的路径完整写法：

1) 内部类定义在object里面，路径：package.object.Inner

object Singleton {
    class Inner
}

val x = new p1.p2.p3.Singleton.Inner

2) 内部类定义在class/trait 里

//2.1) 直接在外部类中使用内部类型，路径：this 或 Outter.this 

class A {
    class B
    val b = new B // 相当于 A.this.B
}   

//2.2) 在子类中使用父类的内部类型，路径：super 或 Child.super

class A  { class B }
class C extends A { val x = new super.B } // 相当于 C.super.B

//2.3) 在其他类中使用，路径：outter(外部类实例)

class A  { class B }
class C { 
    val a = new A
    val x = new a.B  
}

那现在的问题来了，怎么让 a1.foo 方法可以接收 b2 参数 ？

class A { 
    class B; 
    def foo(b:B)  // 接收所有的B类型实例，而不只是foo的调用者实例(a1)路径下B类型的对象
         println(b) 
}

这又引出一个概念：类型投影(type projection)

在scala里，内部类型(排除定义在object内部的)，想要表达所有的外部类A实例路径下的B类型，即对 a1.B 和 a2.B及所有的 an.B类型找一个共同的父类型，这就是类型投影，用 A#B的形式表示。

        A#B
        / \
       /   \
     a1.B  a2.B

这样，我们只要修改一下 foo 方法里的参数类型

def foo(b: A#B)

就可以调用 a1.foo(b2) 了。

我们回头来对比一下scala里的类型投影与java里的内部类型的概念，java里的内部类型在写法上是 Outter.Inner 它其实等同于scala里的投影类型 Outter#Inner，java里没有路径依赖类型的概念，比较简化。

对于单例类型(singleton type)，在《scala impatient》这本书(中文版：快学scala)里有提到过，当时读的时候，扫了一下，以为就是指scala里用object定义的这种单例对象呢，没有仔细看，最近才发现其实singleton type 是所有实例都可以有

scala> object A

scala> A.getClass
res2: Class[_ <: A.type] = class A$

scala> typeOf[A.type]
res0: reflect.runtime.universe.Type = A.type

对于这种单例，它的类型与它的类不同，要用 A.type 来表示。
这有点怪，通常我们不会用它，比如下面的方式都多此一举：

scala> val a : A.type = A

scala> def foo() : A.type = A

一方面因为scala有类型推导的功能，另一方面，因为单例是唯一的，A.type类型只有唯一的实例A(排除null)，我需要的话直接用A就好了。

不过我们讨论的话题重点是 singleton type，想象一下A是一个对象实例，是否对任何实例x都存在一个x.type这样的类型呢？

scala> class A

scala> val a = new A

scala> typeOf[a.type]
res0: reflect.runtime.universe.Type = a.type

wow，真的存在。再用这个类型声明一个变量看看：

scala> val x:a.type = a
x: a.type = A@6738694b

灵的，如果赋一个非a的实例呢？

scala> val x:a.type = a2
<console>:13: error: type mismatch;
     found   : a2.type (with underlying type A)
     required: a.type

scala> typeOf[a.type] == typeOf[A]  // a.type 与 A 不是同一个类型
res2: Boolean = false

scala> typeOf[a.type] == typeOf[a2.type] // a.type 与 a2.type 也不同
res1: Boolean = false

scala> typeOf[a.type] <:< typeOf[A] // a.type 是 A 类型的子类型
res5: Boolean = true

看到了，a.type 与 a2.type 是不同的类型！a.type也是单例类型，它也只有唯一的实例: a (排除null)

所有的对象实例都有一个x.type的单例类型，它只对应当前对象实例。这么做有什么意义呢？

从这里看到一种情况，在“链式”调用风格下，有适用的场景：

class A {def method1: A = this }
class B extends A {def method2: B = this}

val b = new B
b.method2.method1  // 可以工作
b.method1.method2  // 不行，提示：error: value method2 is not a member of A

有些人很喜欢用 x.foo.bar 这样的方式连续的去操作，这种风格也成为”链式调用”风格，它要求方法返回的必须是当前对象类型，以便连贯的调用方法。不过上面，因为父类中声明的method1方法返回类型限制死了就是A类型(不写返回值类型，用类型推导也一样)，导致子类对象调用完method1之后，类型已经变成了父类型，无法再调用子类型中的方法了。解决方法是：

class A { def method1: this.type = this } 
class B extends A { def method2 : this.type = this } 

val b = new B
b.method1.method2  // ok

把返回类型都改为了 this.type 单例类型，就灵了。它利用了this关键字的动态特性来实现的，在执行b.method1 的时候，method1返回值类型this.type 被翻译成了B.this.type

scala> b.method1
res0: b.type = B@ca5bdb6

这样不同的对象实例在执行该方法的时候，返回的类型也是不同的(都是当前实例的单例类型)。

小结，单例类型是个特殊的类型，单例类型绑定(依赖)在某个对象实例上，每个对象实例都有它的单例类型。不过它的场景并不多见。