类#

class类型是面向对象编程中的经典概念, 仓颉中同样支持使用class来实现面向对象编程

class与struct的主要区别在于, class是引用类型, struct是值类型, 它们在赋值或传参时行为是不同的

class之间可以继承, 但struct之间不能继承

本节依次介绍如何定义class类型, 如何创建对象, 以及class的继承

This类型#

在类内部, 支持This类型占位符, 代指当前类的类型

它只能被作为实例成员函数的返回类型来使用

当使用子类对象调用在父类中定义的返回This类型的函数时, 该函数调用的类型会被识别为子类类型, 而非定义所在的父类类型

如果实例成员函数没有声明返回类型, 并且只存在返回This类型表达式时, 当前函数的返回类型会推断为This

示例如下:

1
open class C1 {
2
    func f(): This {                      // 函数类型是`() -> C1`
3
        return this
4
    }
5

6
    func f2() {                           // 函数类型是`() -> C1`
7
        return this
8
    }
9

10
    public open func f3(): C1 {
11
        return this
12
    }
13
}
14
class C2 <: C1 {
15
    // 成员函数 f 是从 C1 继承的, 现在 此函数的类型是`() -> C2`
16
    public override func f3(): This {     // Ok
17
        return this
18
    }
19
}
20

21
var obj1: C2 = C2()
22
var obj2: C1 = C2()
23

24
var x = obj1.f()                          // 在编译过程中, x 的类型为 C2
25
var y = obj2.f()                          // 在编译过程中, y 的类型为 C1

This是仓颉中的一个类型占位符, 它表示所在class这个类型, 但只能用与class成员函数的返回值类型

但要注意, 如果使用子类实例 调用父类的This作为返回值类型的函数, This表示子类类型

文档中:

1
var obj1: C2 = C2()
2
var obj2: C1 = C2()
3

4
var x = obj1.f()                          // 在编译过程中, x 的类型为 C2
5
var y = obj2.f()                          // 在编译过程中, y 的类型为 C1

编译过程中, x和y的识别类型是不同的, 即 是obj1和obj2的声明类型

但, 运行过程中, 是一种动态多态行为, 实际调用类型均为C2

为什么存在这个差异呢?

因为要保证语法合法, 你不能尝试使用obj2直接调用C2自己的成员函数, 这是非法行为

1
import std.reflect.*
2

3
main() {
4
    println(TypeInfo.of(x))
5
    println(TypeInfo.of(y))
6

7
    return 0
8
}

这个打印:

1
Main.C2
2
Main.C2

创建对象#

定义了class类型后, 即可通过调用其构造函数来创建对象(通过class类型名调用构造函数)

例如, 下例中通过Rectangle(10, 20)创建Rectangle类型的对象并赋值给变量r

创建对象之后, 可以通过对象访问(public修饰的)实例成员变量和实例成员函数

例如, 下例中通过r.width和r.height可分别访问r中width和height的值, 通过r.area()可以调用成员函数area

1
class Rectangle {
2
    let width: Int64
3
    let height: Int64
4

5
    public init(width: Int64, height: Int64) {
6
        this.width = width
7
        this.height = height
8
    }
9

10
    public func area() {
11
        this.width * this.height
12
    }
13
}
14
let r = Rectangle(10, 20) // r.width = 10, r.height = 20
15
let width = r.width       // width = 10
16
let height = r.height     // height = 20
17
let a = r.area()          // a = 200

如果希望通过对象去修改成员变量的值(不鼓励这种方式, 最好还是通过成员函数去修改), 需要将class类型中的成员变量定义为可变成员变量(即使用var定义)

举例如下:

1
class Rectangle {
2
    public var width: Int64
3
    public var height: Int64
4

5
    public init(width: Int64, height: Int64) {
6
        this.width = width
7
        this.height = height
8
    }
9

10
    public func area() {
11
        width * height
12
    }
13
}
14

15
main() {
16
    let r = Rectangle(10, 20) // r.width = 10, r.height = 20
17
    r.width = 8               // r.width = 8
18
    r.height = 24             // r.height = 24
19
    let a = r.area()          // a = 192
20
}

class对象(实例)的创建, 很简单, 即 使用类名调用构造函数, 类名(参数列表)

创建完成之后, 就可以通过实例访问可访问的成员变量、成员函数

使用var定义的成员变量可以被修改, 但 仓颉不建议直接通过实例修改成员变量的值, 最好还是通过成员函数来修改

不同于struct, 对象在赋值或传参时, 不会将对象进行复制, 多个变量指向的是同一个对象, 通过一个变量去修改对象中成员的值, 其他变量中对应的成员变量也会被修改

以赋值为例, 下面的例子中, 将r1赋值给r2之后, 修改r1的width和height的值, r2的width和height值也同样会被修改

1
class Rectangle {
2
    var width: Int64
3
    var height: Int64
4

5
    public init(width: Int64, height: Int64) {
6
        this.width = width
7
        this.height = height
8
    }
9

10
    public func area() {
11
        this.width * this.height
12
    }
13
}
14
main() {
15
    var r1 = Rectangle(10, 20) // r1.width = 10, r1.height = 20
16
    var r2 = r1                // r2.width = 10, r2.height = 20
17
    r1.width = 8               // r1.width = 8
18
    r1.height = 24             // r1.height = 24
19
    let a1 = r1.area()         // a1 = 192
20
    let a2 = r2.area()         // a2 = 192
21
}

class是引用类型的, class对象在赋值或传参是, 不会发生拷贝, 而是引用

即, 新变量或形参 会引用(指向)原对象

多次赋值, 所有变量都是引用同一个原对象

此时, 通过其中一个变量修改对象成员的值, 所有变量再访问对象成员的值都会发生改变

因为, 都引用同一个对象

这样理解仓颉中的引用类型:

创建引用类型实例(对象) 赋值给变量, 就是变量引用(指向)了实例, 并不表示此变量就是实例, 变量与引用类型实例之间的关系是引用(指向)关系

如此, 你通过变量传参或赋值, 都只是建立了新的引用关系

如果, 给此变量重新赋值, 就是改变了此变量的引用关系, 此变量就不再引用之前的实例

仓颉的引用类型, 变量与实例之间的关系, 不同于C++的引用变量, C++引用变量定义之后无法改变引用对象

变量和实例是两个有关联的东西, 变量也可以重新修改指向, 可以类比一下C/C++的指针, 但又有很大不同

class的继承#

像大多数支持class的编程语言一样, 仓颉中的class同样支持继承

如果类B继承自类A, 则称A为父类, B为子类

子类将继承父类中 除private成员和构造函数以外 的所有成员

抽象类总是可被继承的, 故抽象类定义时的open修饰符是可选的, 也可以使用 sealed修饰符修饰抽象类, 表示该抽象类只能在本包被继承

但非抽象的类可被继承是有条件的: 定义时必须使用修饰符open修饰

当带open修饰的实例成员被class继承时, 该open的修饰符也会被继承

当非open修饰的类中存在open修饰的成员时, 编译器会给出告警

可以在子类定义处通过<:指定其继承的父类, 但要求父类必须是可继承的

例如, 下面的例子中, class A使用open修饰, 是可以被类B继承的, 但是因为类B是不可继承的, 所以C在继承B的时候会报错

1
open class A {
2
    let a: Int64 = 10
3
}
4

5
class B <: A {                    // Ok, 'B' 继承自 'A'
6
    let b: Int64 = 20
7
}
8

9
class C <: B {                    // Error, 'B' 不能被继承
10
    let c: Int64 = 30
11
}

class仅支持单继承, 因此下面这样一个类继承两个类的代码是不合法的(&是类实现多个接口时的语法, 详见 接口 )

1
open class A {
2
    let a: Int64 = 10
3
}
4

5
open class B {
6
    let b: Int64 = 20
7
}
8

9
class C <: A & B {                // Error, 'C' 只能继承与一个类(单继承)
10
    let c: Int64 = 30
11
}

仓颉class存在继承机制, 但 只允许单继承

继承的语法为:

1
open class ClassBase {}
2

3
class ClassSuper <: ClassBase {}

只有open修饰的类能够被继承, 即 作为父类

如果要继承于一个父类, 类名后紧跟<:并指明父类, 如果尝试使用&符号连接多个父类进行继承, 是不被允许的, 因为仓颉只允许单继承

TIP

仓颉class继承的语法, 与实现接口的语法是一致的

不同的是, 实现接口可以使用&连接多个接口, 以实现多个接口, 但多继承不被允许

如果同时 进行继承和实现接口, 那么 父类必须为<:之后的首个标识符

即, class ClassSuper <: ClassBase & Interface1 & Interface2 & Interface3 {}

抽象类总是可被继承的, 默认具有open语义, 所以显式的open声明是可忽略的

抽象类还可以使用sealed修饰, 以此限制此抽象类只能在本包中被继承

因为类是单继承的, 所以任何类都最多只能有一个直接父类

对于定义时指定了父类的class, 它的直接父类就是定义时指定的类, 对于定义时未指定父类的class, 它的直接父类是Object类型

Object是所有类的父类(注意, Object没有直接父类, 并且Object中不包含任何成员)

因为子类是继承自父类的, 所以子类的对象天然可以当做父类的对象使用, 但是反之不然

例如, 下例中B是A的子类, 那么B类型的对象可以赋值给A类型的变量, 但是A类型的对象不能赋值给B类型的变量

1
open class A {
2
    let a: Int64 = 10
3
}
4

5
class B <: A {
6
    let b: Int64 = 20
7
}
8

9
let a: A = B()                // Ok, 子类对象可以赋值给父类变量
10

11
open class A {
12
    let a: Int64 = 10
13
}
14

15
class B <: A {
16
    let b: Int64 = 20
17
}
18

19
let b: B = A()                // Error, 父类对象不能赋值给子类变量

class定义的类型不允许继承类型本身

1
class A <: A {}               // Error, 'A' 不能继承于自身

仓颉所有类都是Object类的子类, 即 如果一个类没有显式指定继承的父类, 也默认继承于Object类(此类没有任何成员, 且没有直接父类)

子类是父类的子类型, 所以子类对象天然可以做为父类对象使用

所以, 子类对象能够赋值给父类变量, 但反之的不行

抽象类可以使用 sealed修饰符, 表示被修饰的类定义 只能在本定义所在的包内被其他类继承

sealed已经蕴含了public/open的语义, 因此定义sealed abstract class时若提供public/open修饰符, 编译器将会告警

sealed的子类可以不是sealed类, 仍可被open/sealed修饰, 或不使用任何继承性修饰符

若sealed类的子类被open修饰, 则其子类可在包外被继承

sealed的子类可以 不被public修饰(注意, 不是 不可以, 而是 可以不)

1
package A
2
public sealed abstract class C1 {}                // Warning, 冗余修饰符, 'sealed' 已存在 'public' 语义
3
sealed open abstract class C2 {}                  // Warning, 冗余修饰符, 'sealed' 已存在 'open' 语义
4
sealed abstract class C3 {}                       // OK, 使用 'sealed' 时, 'public' 是可选的
5

6
class S1 <: C1 {}                                 // OK
7
public open class S2 <: C1 {}                     // OK
8
public sealed abstract class S3 <: C1 {}          // OK
9
open class S4 <: C1 {}                            // OK

1
package B
2
import A.*
3

4
class SS1 <: S2 {}                                // OK
5
class SS2 <: S3 {}                                // Error, S3 在 package A 中被 sealed 修饰, 不能在这里被继承
6
sealed class SS3 {}                               // Error, 'sealed' 不能修饰非抽象类

sealed修饰符, 用来修饰抽象类, 不能修饰非抽象类, 隐式包含public和open语义

被sealed修饰的类, 被限制 只能在定义此类的包中被继承

但, sealed类的子类, 其可访问性、可继承性与其他普通的类保持一致, 即 根据 是否open和其可访问性修饰符决定