文章摘要
GPT 4
此内容根据文章生成，并经过人工审核，仅用于文章内容的解释与总结

说在前面

经过几篇的无精打采，终于到了最熟悉的一部分知识，看看跟Java的类有何区别。

类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
class Emplyee{
    let hours : Int
    init(hours: Int){
        self.hours = hours
    }
    
    func printSummary(){
        print("我每天工作 \(hours) 小时")
    }
}

class Boss:Emplyee{
    func work(){
        print("抱歉，我是老板，我不用工作")
    }
}

class Developer:Emplyee{
    func work(){
        print("我每天敲代码 \(hours) 小时")
    }
    override func printSummary() {
        print("我是个程序员，我每天工作 \(hours) 小时")
    }
}

let boss = Boss(hours: 8)
let developer = Developer(hours: 10)
boss.work()
developer.work()
boss.printSummary()
developer.printSummary()

继承的概念无需多提，只说区别：swift的继承用 子类:父类 来表示，重写方法在子类方法前加 override 的关键字。

如果你想让一个类不能被继承，那么你可以用 final 关键词来修饰这个类。

如何拷贝类

1
2
3
4
5
6
7
8
9
10
11
12
class User{
    var username = "Yikun" 
}

var user1 = User()
var user2 = user1
user2.username = "易困"
print(user1.username)
print(user2.username)
//输出
//易困
//易困

swift的结构体是值类型，类是引用类型。

1
2
3
4
5
6
7
8
9
//这种方法可以实现类的copy
class User{
    var username = "Yikun"
    func copy() -> User{
        let user = User()
        user.username = username
        return user
    }
}

生命周期

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class User{
    var id: Int
    
    init(id: Int){
        self.id = id
        print("用户\(id):我初始化了")
    }
 
    deinit{
        print("用户\(id):我G了")
    }
}

for i in 1...3 {
    let user = User(id:i)
    print("用户\(user.id):正在执行")
}
//输出
//用户1:我初始化了
//用户1:正在执行
//用户1:我G了
//用户2:我初始化了
//用户2:正在执行
//用户2:我G了
//用户3:我初始化了
//用户3:正在执行
//用户3:我G了

生命周期其实是我按其他语言的称呼这么叫的，swift把init叫构造器，deinit叫析构器，init构造函数在初始化时被调用，deinit析构函数用于在对象被销毁之前执行清理操作。 当对象的生命周期即将结束时，析构函数会自动被调用。

总结

  • 类与结构有很多共同之处。
  • 类可以从其他类继承，因此它们可以访问其父类的属性和方法。
  • Swift 不会为类生成成员初始化器（不会自动创建一个将所有成员属性进行初始化的默认初始化器）。
  • 类实例的副本指向同一个实例。
  • 当实例的最后一个副本被销毁时，类会自动调用类的析构器（deinit 方法）。
  • 您可以更改常量类实例内的变量属性。

课后作业

为动物创建类层次结构 ，从 Animal 开始。

  • 添加一个 legs 属性，表示动物的腿数。
  • 将 Dog 设为 Animal 的子类，为其提供用于打印狗叫字符串的 speak() 方法，但每个子类应打印不同的内容。
  • 将 Corgi（柯基） 和 Poodle（贵宾） 设为 Dog 的子类
  • 将 Cat 设为 Animal 的子类。添加一个 speak() 方法，每个子类打印不同的内容，以及一个使用初始化程序设置的 isTame（驯服/家养） 布尔值。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
class Animal{
    var legs: Int
    init(legs: Int){
        self.legs = legs
    }
}

class Dog: Animal{
    func speak(){
        print("汪汪！")
    }
}

class Corgi: Dog{
    override func speak() {
        print("柯基的汪汪！")
    }
}
class Poodle: Dog{
    override func speak() {
        print("贵宾的汪汪！")
    }
}

class Cat: Animal{
    var isTame: Bool
    init(legs: Int,isTame: Bool) {
        self.isTame = isTame
        super.init(legs: legs)
    }
    func speak(){
        print("喵喵~")
    }
}

var corgi = Corgi(legs: 4)
corgi.speak()
var poodle = Poodle(legs: 4)
poodle.speak()
var cat = Cat(legs: 4,isTame: true)
cat.speak()
//输出
//柯基的汪汪！
//贵宾的汪汪！
//喵喵~