class A {
    fn t() {
        "A::t"
    }
}

class B {
    fn t() {
        "B::t"
    }
}

class C {
    extends A {
        fn t() {
            "(C override A)::t"
        }
    }
    extends B {
    }

    fn t() {
        "C::t"
    }
}

class D {
    extends B {
    }
    extends C {
        fn t() {
            parent.t()
            (parent as A).t()
            (parent as B).t()
            "(D override C)::t"
        }
    }
    fn t() {
        "D::t"
    }
}

C c = new c()
c.t() // C::t
(c as A).t() // (C override A)::t
(c as B).t() // B::t

D d = new D()
d.t() // D::t
(d as A).t() // (C override A)::t
(d as B).t() // B::t
(d as C).t() // C::t
             // (C override A)::t
             // B::t
             // (D override C)::t

这里的as其实是类型声明或强制类型转换。

对于类继承的所有父类，都有一个独立的域。

对象通过对不同的声明类型使用不同的方法，到达多态的效果，即使类中有多个重名方法也不受影响。

但是要为了解决菱形继承的问题：

class A {
    fn t() {
        "A::t"
    }
}

class B {
    fn t() {
        "B::t"
    }
}

class C {
    extends A {
        fn t() {
            "(C override A)::t"
        }
    }
    extends B {
        fn t() {
            "(C override B)::t"
        }
    }
}

class D {
    extends A {}
    extends B {}
}

fn c_a_t(c: C(A)) {
    c.t()
}

fn c_b_t(c: C(B)) {
    c.t()
}

// fn c_t(c: C) {
//     c.t() // 编译错误！不知道使用哪一个t()
// }

D d = new D()
(d as A).t() // A::t
(d as B).t() // B::t
// d.t() // 编译错误！不知道使用哪一个t()
// (d as C).t() // 编译错误！不知道使用哪一个t()
                // 但是如果确实要将d多态为D，就要明确要使用的类
(d as C(A)).t() // (C override A)::t
c_a_t.t() // (C override A)::t
(d as C(B)).t() // (C override B)::t
c_b_t.t() // (C override B)::t

Last modified on 2016-06-10