关于Scala的路徑依赖类型（Path-dependent type）

         咋看这个术语，有点吓倒。其实不是什么新东西，也是讲关于内部类和外部类的事，不过二者有点区别。在Scala中，内部类和外部类的一些行为特性和Java差很少。 请看以下的Scala代码:

class Outer {
    private val x = 10
    class Inner {
        private val y = x + 10
    }
}

val outer = new Outer
val inner =  new outer.Inner
// inner变量能够显式声明类型
val inner: outer.Inner = new outer.Inner

 内部类Inner能够存取外部类成员（包括private成员），但外部类不能存取内部类的private成员. 内部类之因此能存取外部类的成员，是由于内部类隐含地持有外部类的实例。这点和Java是同样的，上述的代码能够用Java语言来表达： 

public class Op {

    public void test1(){
        Outer outer  = new Outer();
        Outer.Inner inner = outer.new Inner();
        System.out.println(inner);
    }

    public static void main(String[] args) {
        Op op = new Op();
        op.test1();
    }
}

class Outer {
    private int x = 10;
    class Inner {
        private int y = x + 10;
    }
}

注意Java和scala在建立成员内部类时的细微差异。

        Scala的内部类比Java的内部类具备更多特性，所以Scala引入了路径依赖类型（Path-dependent type)的概念。像outer.Inner这样的类型就称为路径依赖类型。所谓路径，指的就是参考外部类所创建的实例的名称。 就outer.Inner这个类型来讲，路径为outer。更重要的是，不一样路径表明不一样的类型。好比：

val o1 = new Outer
val o2 = new Outer
val i1 =  new o1.Inner
val i2 =  new o2.Inner

上述的i1,i2分别引用了不一样类型的实例,其中i1所引用的实体类型是o1.Inner, i2引用的实体类型是o2.Inner。假如你尝试把o1.Inner的实例赋值给声明为o2.Inner类型的变量，编译器会报错:

val o1 = new Outer
val o2 = new Outer
val i: o2.Inner = new o1.Inner   // 编译错误,类型不匹配

注意： 路径依赖的是路径的名称，与路径所引用的实例无关，请看例子： 

val o1 = new Outer
val o2 = o1
val i1: o1.Inner = new o1.Inner
val i2: o2.Inner = new o1.Inner   // 编译错误。尽管o2和o1引用同一个实例，但o1.Inner和o2.Inner是不一样的，Scala编译器只根据路径名进行区分

事实上, o1.Inner和o2.Inner都是Outer#Inner的子类型， 请看例子

val o1 = new Outer
val o2 = new Outer
val i1: Outer#Inner = new o1.Inner
val i2: Outer#Inner = new o2.Inner

 路径依赖类型能够被继承，请看例子

val o = new Outer
class Some extends o.Inner
val oi: Outer#Inner = new Some

 注意：Outer#Inner是不能被继承的

 此外，路径依赖类型所在的路径必须是不可变的值。例如

var o1 = new Outer val i = new o1.Inner // 编译错误。由于o1是var

这也很好理解，若是o1是var，那么他的类型将是不肯定的，从而致使其路径依赖类型也不肯定。

通常地，x0.x1.x2...xn.T是路径一类类型，只要知足：

a) x0 是不可变值（即x0是val所声明的变量）

b) x1, x2, ..., xn 都是不可变的属性

c) T 是xn内部类 

 

下面看一个负责的例子：

class Food

class Fish extends Food {
    override def toString = "魚"
}

abstract class Animal {
    type F <: Food
    def eat(f: F)
}

class Cat extends Animal {
    type F = Fish
    def eat(fish: Fish) {
        println("吃" + fish)
    }
}

val cat1 = new Cat
val cat2 = new Cat
cat1.eat(new cat1.F)  // 吃魚
cat2.eat(new cat2.F)  // 吃魚

对于Cat类而言，F是其类型成员之一, 但这里 cat1.F和cat2.F表明相同的类型，也就是说你能够把一个cat2.F类型的实例传递给一个声明为cat1.F类型的变量. 实际上，上述代码的最后四行等价于如下的代码：

type F1 = Fish
type F2 = Fish
cat1.eat(new F1)   // 吃魚
cat1.eat(new F2)   // 吃魚

固然new Cat#F也是合法的

说了这么多，大家以为这种特性有什么用途？若是你知道，请评论一下。