覆盖的定义#

子类型中定义父类型中已经存在的同名非抽象、具有open语义的实例函数时, 允许使用可选的override进行修饰以表示 是对父类型中同名函数的覆盖

函数的覆盖需要遵循以下规则:

• 覆盖函数与被覆盖函数的函数名必须相同

• 覆盖函数与被覆盖函数的参数列表必须相同

  参数列表相同指函数的参数个数、参数类型相同

• 覆盖函数的返回类型与被覆盖函数的返回类型相同或为其子类型

• 同一个函数覆盖多个父作用域中出现的函数, 每个函数的覆盖规则由上面的其他规则确定

示例:

• 类C1、C2, 接口I中的函数f, 参数参数列表相同, 返回类型相同, 满足覆盖的要求

• 类C1与C2中的函数f1, 参数列表相同, 在C1中的返回类型是Father, 在C2中的返回类型是Child, 由于Child是Father的子类型, 因此满足覆盖的规则

1
open class Father {}
2
class Child <: Father {}
3

4
open class C1 {
5
    public open func f() {}
6
    public open func f1(): Father { Father() }
7
}
8

9
interface I {
10
    func f() {}
11
}
12

13
class C2 <: C1 & I {
14
    public override func f() {}                       // OK
15
    public override func f1(): Child { Child() }      // OK
16
}

需要注意的一些细节包括:

1. 类中用private修饰的函数不会被继承, 无法在子类中访问

2. 静态函数不能覆盖实例函数

覆盖一定是出现在存在继承关系的两个类型中的

只能覆盖父类型中被open修饰的函数

覆盖要保证函数名和参数列表完全相同, 返回值可以是父类中函数返回值类型的子类型

仓颉中的覆盖, 其实类似于C++类中的虚函数重写, 可以用以实现动态多态

覆盖的调用#

如果子类型覆盖了父类型中的函数, 并且在程序中调用了此函数, 则编译器会根据 运行时对象指向的类型 来选择执行此函数的哪个版本

以下示例中, 在类C1定义了函数f, 其子类C2中覆盖了f, 同时定义了类型为C1的变量a与b, 并将C1的对象myC1赋给a, 将C2的对象myC2赋给b

通过a和b来调用函数f时, 会在运行时根据它们实际的类型来选择对应的函数

1
open class C1 {
2
    public open func f(): Unit {
3
        return
4
    }
5
}
6
class C2 <: C1 {
7
    public override func f(): Unit {
8
        return
9
    }
10
}
11

12
var myC1 = C1()
13
var myC2 = C2()
14

15
// 将父类 C1 的对象赋值给 C1 类型的变量
16
var a: C1 = myC1
17
// 将子类 C2 的对象赋值给 C1 类型的变量
18
var b: C1 = myC2
19

20
// 根据运行时的对象类型调用 C1 的 f
21
var c = a.f()
22
// 根据运行时的对象类型调用 C2 的 f
23
var d = b.f()

覆盖的调用, 其实可以实现动态多态调用

重定义函数的定义#

子类型中定义父类型中已经存在的 同名非抽象静态函数 时, 允许使用可选的redef进行修饰以表示是对父类型中同名函数的重定义

函数的重定义需要遵循以下规则:

• 函数与被重定义函数的函数名必须相同

• 函数与被重定义函数的参数列表必须相同

  参数列表相同指函数的参数个数、参数类型相同

• 函数的返回类型与被重定义函数的返回类型相同或为其子类型

• 如果被重定义函数为泛型函数, 则要求 重定义函数的 类型变元约束 比被实现函数更宽松或相同

• 同一个函数 重定义 多个父作用域中出现的函数, 每个函数的覆盖规则由上面的其他规则确定

这里的重定义不是指重复定义, 而是指重新定义

重定义与覆盖的语法类似, 但 重定义主要是针对静态成员的概念

示例:

• 类C1、C2, 接口I中的函数f, 参数参数列表相同, 返回类型相同, 满足重定义的要求

• 类C1与C2中的函数f1, 参数列表相同, 在C1中的返回类型是Father, 在C2中的返回类型是Child, 由于Child是Father的子类型, 因此满足重定义的规则

1
open class Father {}
2
class Child <: Father {}
3

4
open class C1 {
5
    public static func f() {}
6
    public static func f1(): Father { Father() }
7
}
8

9
interface I {
10
    static func f() {}
11
}
12

13
class C2 <: C1 & I {
14
    public redef static func f() {}                       // OK
15
    public redef static func f1(): Child { Child() }      // OK

示例: 基类Base中的函数f和g为泛型函数, 子类E和F满足 重定义函数 比 被重定义函数的类型变元约束 更宽松或相同的要求, 编译成功; 子类D不满足要求, 则编译报错

1
// C <: B <: A
2
open class Base {
3
    static func f<T>(a: T): T where T <: B {...}
4
    static func g<T>(): T where T <: B {...}
5
}
6

7
class D <: Base  {
8
    redef static func f<T>(a: T): T where T <: C {...}        // Error, 更严格的约束
9
    redef static func g<T>(): T where T <: C {...}            // Error, 更严格的约束
10
}
11

12
class E <: Base  {
13
    redef static func f<T>(a: T): T where T <: A {...}        // OK, 更宽松的约束
14
    redef static func g<T>(): T where T <: A {...}            // OK, 更宽松的约束
15
}
16

17
class F <: Base  {
18
    redef static func f<T>(a: T): T where T <: B {...}        // OK, 相同的约束
19
    redef static func g<T>(): T where T <: B {...}            // OK, 相同的约束
20
}

redef修饰符不能用于修饰静态初始化器(因为静态初始化器不能被显式调用), 否则编译器会报告错误

重定义函数的调用#

如果子类型重定义了父类型中的函数, 并且在程序中调用了此函数, 则编译器会根据类型来选择执行此函数的哪个版本

以下示例中, 在类C1定义了函数f, 其子类C2中重定义了f

通过C1和C2来调用函数f时, 会在编译时根据它们的类型来选择对应的函数

1
open class C1 {
2
    static func f(): Unit {
3
        return
4
    }
5
}
6
class C2 <: C1 {
7
    redef static func f(): Unit {
8
        return
9
    }
10
}
11

12
// 调用 C1 的 f
13
var c = C1.f()
14
// 调用 C2 的 f
15
var d = C2.f()

重定义其实不存在根据类型动态派发执行函数的情况, 因为只能通过类型调用, 此时类型是确定好的

重定义函数的调用, 是在编译期就确定好的