继承（Inheritance）

值类型（枚举、结构体）不支持继承，只有类支持继承
没有父类的类，称为：基类，Swift并没有像OC、Java那样的规定：任何类最终都要继承自某个基类。
子类可以重写父类的下标、方法、属性，重写必须加上override关键字
创建三个类，继承关系： ErHa 继承于 Dog 继承于 Animal

  1. class Animal {
  2.     var age = 0
  3. }
  5. class Dog: Animal {
  6.     var weight = 0
  7. }
  9. class ErHa: Dog {
  10.     var iq = 0
  11. }

分别创建Animal、Dog、ErHa实例对象，观察内存信息：

  1. let a = Animal()
  2. a.age = 10
  4. print(Mems.size(ofRef: a)) // 32
  5. print(Mems.memStr(ofRef: a))
  7. // 一个Animal的实例对象占用32个字节
  8. /*
  9.  0x000000010000c3d0 8个字节：指向类型信息的地址
  10.  0x0000000000000003 8个字节：引用计数相关
  11.  0x000000000000000a 8个字节：保存age属性
  12.  0x0000000105a35830 8个字节：内存对齐
  13.  */
  15. let d = Dog()
  16. d.age = 10
  17. d.weight = 20
  19. print(Mems.size(ofRef: d)) // 32
  20. print(Mems.memStr(ofRef: d))
  22. // 一个Dog的实例对象占用32个字节
  23. /*
  24.  0x000000010000c480 8个字节：指向类型信息的地址
  25.  0x0000000000000003 8个字节：引用计数相关
  26.  0x000000000000000a 8个字节：保存age属性
  27.  0x0000000000000014 8个字节：保存weight属性
  28.  */
  30. let e = ErHa()
  31. e.age = 10
  32. e.weight = 20
  33. e.iq = 30
  35. print(Mems.size(ofRef: e)) // 48
  36. print(Mems.memStr(ofRef: e))
  38. // 一个ErHa的实例对象占用48个字节
  39. /*
  40.  0x000000010000c550 8个字节：指向类型信息的地址
  41.  0x0000000000000003 8个字节：引用计数相关
  42.  0x000000000000000a 8个字节：保存age属性
  43.  0x0000000000000014 8个字节：保存weight属性
  44.  0x000000000000001e 8个字节：保存iq属性
  45.  0x0003000000000078 8个字节：内存对齐
  46.  */

重写实例方法、下标

  1. class Animal {
  2.     func speak() {
  3.         print("Animal speak")
  4.     }
  6.     subscript(index: Int) -> Int {
  7.         return index
  8.     }
  9. }
  11. var a = Animal()
  12. a.speak()
  13. print(a[6])
  15. class Dog: Animal {
  16.     /// 重写实例方法
  17.     override func speak() {
  18.         super.speak()
  19.         print("Dog speak")
  20.     }
  22.     /// 重写下标
  23.     override subscript(index: Int) -> Int {
  24.         return super[index] + 1
  25.     }
  26. }
  28. var d = Dog()
  29. d.speak()
  30. print(d[6])

打印结果：

  1. Animal speak
  2. 6
  4. Animal speak
  5. Dog speak
  6. 7

重写类型方法、下标

被class修饰的类型方法、下标，允许被子类重写

  1. class Animal {
  2.     class func speak() {
  3.         print("Animal speak")
  4.     }
  6.     class subscript(index: Int) -> Int {
  7.         return index
  8.     }
  9. }
  11. Animal.speak()
  12. print(Animal[6])
  14. class Dog: Animal {
  15.     override class func speak() {
  16.         super.speak()
  17.         print("Dog speak")
  18.     }
  20.     override class subscript(index: Int) -> Int {
  21.         return super[index] + 1
  22.     }
  23. }
  25. Dog.speak()
  26. print(Dog[6])

打印结果：

  1. Animal speak
  2. 6
  3. Animal speak
  4. Dog speak
  5. 7

被static修饰的类型方法、下标、不允许被子类重写
image.png

重写属性

1、子类可以将父类的属性（存储、计算）重写为计算属性
2、子类不可以将父类属性重写为存储属性
3、只能重写var属性，不能重写let属性
4、重写时，属性名、类型要一致
5、子类重写后的属性权限，不能小于父类的属性权限

  • 如果如类属性是只读的，那么子类重写后的属性可以是只读的、也可以是可读写的

  • 如果父类属性是可读写的，那么子类重写后的属性也必须是可读写的

    重写实例属性

    ```swift class Point { /// 存储属性 var x: Int = 0

    /// 计算属性 var y: Int {

    1.   set {
    2.       print("Point set y")
    3.       x = newValue / 2
    4.   }
    5.   get {
    6.       print("Point get y")
    7.       return x * 2
    8.   }

    } }

class SubPoint: Point {

  1. /// 重写x为计算属性
  2. override var x: Int {
  3.     set {
  4.         print("SubPoint set x")
  5.         super.x = newValue
  6.     }
  7.     get {
  8.         print("SubPoint get x")
  9.         return super.x
  10.     }
  11. }
  13. /// 重写y为计算属性
  14. override var y: Int {
  15.     set {
  16.         print("SubPoint set y")
  17.         super.y = newValue
  18.     }
  19.     get {
  20.         print("SubPoint get y")
  21.         return super.y
  22.     }
  23. }

}

let sp = SubPoint() print(sp.y)

  1. 打印结果：

SubPoint get y Point get y SubPoint get x 0

  1. 分析：<br />sp.y调用的是子类y的get方法，所以打印SubPoint get y<br />子类y的get方法中调用了super.y，所以打印了Point get y<br />父类y的get方法调用了x * 2，但是当前调用对象是SubPoint，会走到子类x的get方法，所以打印了SubPoint get x<br />从父类继承过来的存储属性，都会分配存储空间，无论是否被重写为计算属性。
  2. <a name="UoYV3"></a>
  3. ## 重写类型属性
  4. 被class修饰的计算类型属性，可以被子类重写<br />被static修饰的类型属性（存储、计算），不可以被子类重写<br />![image.png](https://cdn.nlark.com/yuque/0/2022/png/742903/1642669285692-398ceba7-88ae-4aec-8201-e8c40199188e.png#clientId=u41871de7-1af0-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=313&id=u85e380aa&margin=%5Bobject%20Object%5D&name=image.png&originHeight=313&originWidth=728&originalType=binary&ratio=1&rotation=0&showTitle=false&size=40787&status=done&style=none&taskId=u3e026015-23c6-4270-aed7-820aa364974&title=&width=728)
  5. <a name="o3pJj"></a>
  6. # 属性观察器
  7. 可以在子类中为父类属性（除了只读计算属性、let属性）增加属性观察器
  8. ```swift
  9. class Point {
  10.     var x: Int = 0
  11. }
  13. class SubPoint: Point {
  14.     override var x: Int {
  15.         willSet {
  16.             print("SubPoint willSet x", newValue)
  17.         }
  18.         didSet {
  19.             print("SubPoint didSet x", x, oldValue)
  20.         }
  21.     }
  22. }
  24. var p = SubPoint()
  25. p.x = 10

打印结果：

  1. SubPoint willSet x 10
  2. SubPoint didSet x 10 0

如果父类有自己的属性观察器：

  1. class Point {
  2.     var x: Int = 0 {
  3.         willSet {
  4.             print("Point willSet x", newValue)
  5.         }
  6.         didSet {
  7.             print("Point didSet x", x, oldValue)
  8.         }
  9.     }
  10. }
  12. class SubPoint: Point {
  13.     override var x: Int {
  14.         willSet {
  15.             print("SubPoint willSet x", newValue)
  16.         }
  17.         didSet {
  18.             print("SubPoint didSet x", x, oldValue)
  19.         }
  20.     }
  21. }
  23. var p = SubPoint()
  24. p.x = 10

打印结果：

  1. SubPoint willSet x 10
  2. Point willSet x 10
  3. Point didSet x 10 0
  4. SubPoint didSet x 10 0

如果父类有一个计算属性

  1. class Point {
  2.     var x: Int {
  3.         set {
  4.             print("Point set x", newValue)
  5.         }
  6.         get {
  7.             print("Point get x")
  8.             return 0
  9.         }
  10.     }
  11. }
  13. class SubPoint: Point {
  14.     override var x: Int {
  15.         willSet {
  16.             print("SubPoint willSet x", newValue)
  17.         }
  18.         didSet {
  19.             print("SubPoint didSet x", x, oldValue)
  20.         }
  21.     }
  22. }
  24. var p = SubPoint()
  25. p.x = 10

打印结果：

  1. Point get x
  2. SubPoint willSet x 10
  3. Point set x 10
  4. Point get x
  5. SubPoint didSet x 0 0

第一行打印是获取的oldValue

final

被final修饰的方法、下标、属性，禁止被重写
被final修饰的类，禁止被继承
image.png

多态

结构体

  1. struct Animal {
  2.     func speak() {
  3.         print("Animal speak")
  4.     }
  5.     func eat() {
  6.         print("Animal eat")
  7.     }
  8.     func sleep() {
  9.         print("Animal sleep")
  10.     }
  11. }
  13. var animal = Animal()
  14. animal.speak()
  15. animal.eat()
  16. animal.sleep()

定一个结构体，执行三个方法，观察汇编代码
image.png
调用方法时，直接调用了函数地址，原因是struct不存在继承，所以编译完函数的地址就是确定的。

类

  1. class Animal {
  2.     func speak() {
  3.         print("Animal speak")
  4.     }
  5.     func eat() {
  6.         print("Animal eat")
  7.     }
  8.     func sleep() {
  9.         print("Animal sleep")
  10.     }
  11. }
  13. var animal = Animal()
  14. animal.speak()
  15. animal.eat()
  16. animal.sleep()

观察汇编代码：
image.png
函数的地址是不确定的，是通过计算得出的，在编译时是不确定的。

实现原理探究

  1. class Animal {
  2.     func speak() {
  3.         print("Animal speak")
  4.     }
  5.     func eat() {
  6.         print("Animal eat")
  7.     }
  8.     func sleep() {
  9.         print("Animal sleep")
  10.     }
  11. }
  13. class Dog: Animal {
  14.     override func speak() {
  15.         print("Dog speak")
  16.     }
  17.     override func eat() {
  18.         print("Dog eat")
  19.     }
  20.     func run() {
  21.         print("Dog run")
  22.     }
  23. }
  25. var animal = Animal()
  26. animal.speak()
  27. animal.eat()
  28. animal.sleep()
  30. // 父类类型指针，指向子类类型
  31. animal = Dog()
  32. animal.speak()
  33. animal.eat()
  34. animal.sleep()

打印结果：

  1. Animal speak
  2. Animal eat
  3. Animal sleep
  5. Dog speak
  6. Dog eat
  7. Animal sleep

以dog变量调用sleep方法为例，流程是通过dog指针找到堆空间的dog对象，找到dog对象中的前8个字节
这8个字节是一个指针，指向一块内存区域，这块内存前面保存着dog的类型信息，后面存放了Dog和父类Animal的方法信息。
通过打印这块内存的地址，可以发现是保存在内存的全局区。