Swift語法 Swift5 【11 - 繼承】

  • 作者: Liwx
  • 郵箱: 1032282633@qq.com
  • 源碼: 需要源碼的同學, 可以在評論區留下您的郵箱

iOS Swift 語法 底層原理 與 內存管理分析 專題：【iOS Swift5語法】

00 - 匯編
01 - 基礎語法
02 - 流程控制
03 - 函數
04 - 枚舉
05 - 可選項
06 - 結構體和類
07 - 閉包
08 - 屬性
09 - 方法
10 - 下標
11 - 繼承
12 - 初始化器init
13 - 可選項

目錄

  • 01-繼承(Inheritance)
  • 02-內存結構
  • 03-重寫實例方法、下標
  • 04-重寫類型方法、下標
  • 05-重寫屬性
  • 06-重寫實例屬性
  • 07-重寫類型屬性
  • 08-屬性觀察器(子類為父類存儲屬性添加屬性觀察器)
  • 09-屬性觀察器(子類和父類都實現屬性觀察器)
  • 10-屬性觀察器(子類為父類計算屬性添加屬性觀察器)
  • 11-屬性觀察器(子類為父類類型計算屬性添加屬性觀察器)
  • 12-final

01-繼承(Inheritance)

  • 值類型(枚舉、結構體)不支持繼承, 只有類支持繼承
  • 沒有父類的類,稱為: 基類
    • Swift并沒有像OC、Java那樣的規定: 任何類最終都要繼承自某個基類
  • 子類可以重寫父類的下標、方法、屬性, 重寫必須加上override關鍵字

02-內存結構

  • 類前16個字節是用來存放類型信息和引用計數 

class Animal {
    var age = 0
}

class Dog : Animal {
    var weight = 0
}

class ErHa : Dog {
    var iq = 0
}

let a = Animal()
a.age = 10
print(Mems.size(ofRef: a))  // 32
/*
 0x00000001000073c8  // 類型信息
 0x0000000000000002  // 引用計數
 0x000000000000000a  // 存儲屬性 age
 0x0000000000000000  // 未使用
 */
print(Mems.memStr(ofRef: a))

let d = Dog()
d.age = 10
d.weight = 20
let dd = d
print(dd)
print(Mems.size(ofRef: d))  // 32
/*
 0x0000000100007478  // 類型信息
 0x0000000000000002  // 引用計數
 0x000000000000000a  // 存儲屬性 age
 0x0000000000000014  // 存儲屬性weight
 */
print(Mems.memStr(ofRef: d))

let e = ErHa()
e.age = 10
e.weight = 20
e.iq = 30
print(Mems.size(ofRef: e))  // 48
/*
 0x0000000100008548  // 類型信息
 0x0000000000000002  // 引用計數
 0x000000000000000a  // 存儲屬性 age
 0x0000000000000014  // 存儲屬性weight
 0x000000000000001e  // 存儲屬性iq
 0x0000000000343130  // 未使用
 */

03-重寫實例方法、下標

  • 重寫實例方法下標 override修飾下標方法subscript
    • 調用父類的下標方法subscript: super[index] 
class Animal {
    func speak() {
        print("Animal speak")
    }
    subscript(index: Int) ->Int {
        return index
    }
}
var anim: Animal
anim = Animal()
anim.speak()    // Animal speak
print(anim[6])  // 6

class Cat : Animal {
    override func speak() {
        print("Cat speak")
    }
    override subscript(index: Int) -> Int {
        return super[index] + 1     // 調用父類下標方法subscript
    }
}

anim = Cat()    // 多態, 父類指針指向子類對象
anim.speak()    // Cat speak
print(anim[6])  // 7

04-重寫類型方法、下標

  • 被class修飾的類型方法、下標, 允許被子類重寫
  • 被static修飾的類型方法、下標, 不允許被子類重寫
class Animal {
    class func speak() {
        print("Animal speak")
    }
    class subscript(index: Int) -> Int {
        return index
    }
}

Animal.speak()      // Animal speak
print(Animal[6])    // 6

class Cat : Animal {
    override class func speak() {
        print("Cat speak")
    }
    override class subscript(index: Int) -> Int {  // 如果父類用static修飾下標方法subscript, 報錯: Cannot override static subscript
        return super[index] + 1
    }
}

Cat.speak()         // Cat speak
print(Cat[6])       // 7

05-重寫屬性

  • 子類可以將父類的屬性(存儲、計算)重寫為計算屬性
  • 子類不可以將父類的屬性重寫為存儲屬性
  • 只能重寫var屬性, 不能重寫let屬性
  • 重寫時,屬性名、類型要一致
    子類重寫后的屬性權限不能小于 父類屬性的權限
    • 如果父類屬性是只讀的,那么子類重寫后的屬性可以是只讀的、也可以是可讀寫的
    • 如果父類屬性是可讀寫的,那么子類重寫后的屬性也必須是可讀寫的

06-重寫實例屬性

  • 重寫實例屬性, 存儲，計算屬性重寫
class Circle {
    var radius: Int = 0
    var diameter: Int {
        set {
            print("Circle setDiameter")
            radius = newValue / 2
        }
        get {
            print("Circle getDiameter")
            return radius * 2
        }
    }
}

var circle: Circle
circle = Circle()
circle.radius = 6

// Circle getDiameter
// 12
print(circle.diameter)

// Circle setDiameter
circle.diameter = 20
// 10
print(circle.radius)


class SubCircle : Circle {
    override var radius: Int {
        set {
            print("SubCircle setRadius")
            super.radius = newValue
        }
        get {
            print("SubCircle getRadius")
            return super.radius
        }
    }
    
    override var diameter: Int {
        set {
            print("SubCircle setDiameter")
            super.diameter = newValue
        }
        get {
            print("SubCircle getDiameter")
            return super.diameter
        }
    }
}

circle = SubCircle()
// SubCircle setRadius
circle.radius = 6

// SubCircle getDiameter
// Circle getDiameter
// SubCircle getRadius
// 12
print(circle.diameter)

// SubCircle setDiameter
// Circle setDiameter
// SubCircle setRadius
circle.diameter = 20

// SubCircle getRadius
// 10
print(circle.radius)

07-重寫類型屬性

  • 被class修飾的計算類型屬性, 可以被子類重寫
  • 被static修飾的類型屬性(存儲, 計算), 不可以被子類重寫
class Circle {
    static var radius: Int = 0
    class var diameter: Int {
        set {
            print("Circle setDiameter")
            radius = newValue / 2
        }
        get {
            print("Circle getDiameter")
            return radius * 2
        }
    }
}

class SubCircle : Circle {
//    override var radius: Int {  static修飾的類型屬性不能重寫 // error: property does not override any property from its superclass
//        set {
//            super.radius = 2
//        }
//        get {
//            return 10
//        }
//    }
    override class var diameter: Int {
        set {
            print("SubCircle setDiameter")
            super.diameter = newValue > 0 ? newValue : 0
        }
        get {
            print("SubCircle getDiameter")
            return super.diameter
        }
    }
}

Circle.radius = 6
// 6
print(Circle.radius)
// Circle getDiameter
Circle.diameter = 20
// 10
print(Circle.radius)

print("----")

SubCircle.radius = 6
// SubCircle getDiameter
// Circle getDiameter
// 12
print(SubCircle.diameter)
// SubCircle setDiameter
// Circle setDiameter
SubCircle.diameter = 20
// 10
print(SubCircle.radius)

08-屬性觀察器(子類為父類存儲屬性添加屬性觀察器)

  • 可以在子類中為父類屬性(除了只讀計算屬性、let屬性)增加屬性觀察器
class Circle {
    var radius: Int = 1
    
    let count: Int = 1
    var diameters: Int {    // 只讀計算屬性
        radius * 2
    }
}
class SubCircle : Circle {
    override var radius: Int {
        willSet {
            print("SubCircle willSetRadius", newValue)
        }
        didSet {
            print("SubCircle didSetRadius", oldValue, radius)
        }
    }
    
//    // 不能給let屬性重寫屬性觀察器
//    override let count: Int {   // error: 'let' declarations cannot be observing properties
//        willSet {
//            
//        }
//        didSet {
//        
//        }
//    }
  
//    // 不能給只讀計算屬性重寫屬性觀察器
//    override var diameters: Int { // error: cannot observe read-only property 'diameters'; it can't change
//        willSet {
//
//        }
//        didSet {
//
//        }
//    }
    
}
var circle = SubCircle()

// SubCircle willSetRadius 10
// SubCircle didSetRadius 1 10
circle.radius = 10

09-屬性觀察器(子類和父類都實現屬性觀察器)

class Circle {
    var radius: Int = 1 {
        willSet {
            print("Circle willSetRadius", newValue)
        }
        didSet {
            print("Circle didSetRadius", oldValue, radius)
        }
    }
}

class SubCircle : Circle {
    override var radius: Int {
        
        willSet {
            print("SubCircle willSetRadius", newValue)
        }
        didSet {
            print("SubCircle didSetRadius", oldValue, radius)
        }
    }
}

var circle = SubCircle()
// SubCircle willSetRadius 10
// Circle willSetRadius 10
// Circle didSetRadius 1 10
// SubCircle didSetRadius 1 10
circle.radius = 10
  • 通過匯編觀察(子類和父類都實現屬性觀察器)
image.png
// 根據匯編代碼分析
set {
    call willSet
    // 真正設置值
    call super set
    call didSet
}

10-屬性觀察器(子類為父類計算屬性添加屬性觀察器)

  • 計算屬性沒占用內存,所以使用Copy In Copy Out方式,先調用get方法復制一個副本 
class Circle {
    var radius: Int {
        set {
            print("Circle setRadius", newValue)
        }
        get {
            print("Circle getRadius")
            return 20
        }
    }
}

class SubCircle : Circle {
    override var radius: Int {
        willSet {
            print("SubCircle willSet", newValue)
        }
        didSet {
            print("SubCircle didSet", oldValue, radius)
        }
    }
}

var circle = SubCircle()
// Circle getRadius      // 重寫計算屬性的屬性觀察器，計算屬性原本不占用內存，所以會先調用get方法復制一個副本
// SubCircle willSet 10
// Circle setRadius 10
// Circle getRadius      // 此次打印get是因為父類的radius set方法中調用了newValue
// SubCircle didSet 20 20
circle.radius = 10

11-屬性觀察器(子類為父類類型計算屬性添加屬性觀察器)

  • Xcode 11.4.1 以下代碼報錯, 不知什么原因! 待排查 
class Circle {
    class var radius: Int {
        set {
            print("Circle setRadius", newValue)
        }
        get {
            print("Circle getRadius")
            return 20
        }
    }
}

class SubCircle : Circle {
    override static var radius: Int {
        willSet {
            print("SubCircle willSet", newValue)
        }
        didSet {
            print("SubCircle didSet", oldValue, radius)
        }
    }
}

// Circle getRadius   // oldValue是設置之前的值,所以在即將設置之前會調用getRadius來獲取設置之前的值
// SubCircle willSet 10
// Circle setRadius 10
// Circle getRadius
// SubCircle didSetRadius 20 20
SubCircle.radius = 10

12-final

  • 被final修飾的方法、下標、屬性,禁止被重寫 
class Circle {
    final func test() {
        print("Circle test")
    }
}

class SubCircle : Circle {
   // 不能重寫final修飾的方法
    override final func test() {    // error: instance method overrides a 'final' instance method
    }
}
  • 被final修飾的類,禁止被繼承 
final class Circle {
    var radius: Int = 0
}
// 不能繼承final修飾的類
class SubCircle : Circle {  // error: inheritance from a final class 'Circle'
}

iOS Swift 語法 底層原理 與 內存管理分析 專題：【iOS Swift5語法】

下一篇: 12 - 初始化器init
上一篇: 10 - 下標

最后編輯于 ：
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。
禁止轉載，如需轉載請通過簡信或評論聯系作者。