// 值类型（枚举、结构体）不支持继承，只有类才支持继承
    // swift中不想OC、Java中必须继承至某个父类，默认就是基类
    // 子类可重写父类的下标、方法、属性，重写必须加上override关键字
    
    // 1.内存结构
    func test_memory() {
        class Animal {
            var age = 5
            // 打印Animal实例可知，该类占用24个字节
            // 事实上通过详细分析原理得知，该类的实例内存分为三块
            
            /** Animal 实例 内存结构
             占用3*8=24个字节，由于ios系统分配是以16倍数分配，故分配32个字节
             ┏━━━━━━━━━━━━━━┓        ┏━━━━━━━━━━━━━━━━━━━━━━┓
             ┃ classInfo    ┃        ┃ 0x0000000100078e     ┃
             ┗━━━━━━━━━━━━━━┛        ┗━━━━━━━━━━━━━━━━━━━━━━┛
             ┃ retainCount  ┃        ┃ 0x00000000000001     ┃
             ┗━━━━━━━━━━━━━━┛        ┗━━━━━━━━━━━━━━━━━━━━━━┛
             ┃ var age      ┃        ┃ 0x00000000000005     ┃
             ┗━━━━━━━━━━━━━━┛        ┗━━━━━━━━━━━━━━━━━━━━━━┛
             */
        }
        class Dog: Animal {
            var weight = 7
            
            /** Dog 实例 内存结构
             占用4*8=32个字节，由于ios系统分配是以16倍数分配，故任然分配32个字节
             ┏━━━━━━━━━━━━━━┓        ┏━━━━━━━━━━━━━━━━━━━━━━┓
             ┃ classInfo    ┃        ┃ 0x0000000100078e     ┃
             ┗━━━━━━━━━━━━━━┛        ┗━━━━━━━━━━━━━━━━━━━━━━┛
             ┃ retainCount  ┃        ┃ 0x00000000000001     ┃
             ┗━━━━━━━━━━━━━━┛        ┗━━━━━━━━━━━━━━━━━━━━━━┛
             ┃ var age      ┃        ┃ 0x00000000000005     ┃
             ┗━━━━━━━━━━━━━━┛        ┗━━━━━━━━━━━━━━━━━━━━━━┛
             ┃ var weight   ┃        ┃ 0x00000000000007     ┃
             ┗━━━━━━━━━━━━━━┛        ┗━━━━━━━━━━━━━━━━━━━━━━┛
             */
        }
        class WhiteDog: Dog {
            var height = 15
            /** Dog 实例 内存结构
             占用4*8=40个字节，由于ios系统分配是以16倍数分配，故分配48个字节
             ┏━━━━━━━━━━━━━━┓        ┏━━━━━━━━━━━━━━━━━━━━━━┓
             ┃ classInfo    ┃        ┃ 0x0000000100078e     ┃
             ┗━━━━━━━━━━━━━━┛        ┗━━━━━━━━━━━━━━━━━━━━━━┛
             ┃ retainCount  ┃        ┃ 0x00000000000001     ┃
             ┗━━━━━━━━━━━━━━┛        ┗━━━━━━━━━━━━━━━━━━━━━━┛
             ┃ var age      ┃        ┃ 0x00000000000005     ┃
             ┗━━━━━━━━━━━━━━┛        ┗━━━━━━━━━━━━━━━━━━━━━━┛
             ┃ var weight   ┃        ┃ 0x00000000000007     ┃
             ┗━━━━━━━━━━━━━━┛        ┗━━━━━━━━━━━━━━━━━━━━━━┛
             ┃ var height   ┃        ┃ 0x0000000000000f     ┃
             ┗━━━━━━━━━━━━━━┛        ┗━━━━━━━━━━━━━━━━━━━━━━┛
             */
        }
        // 综上
        // swift中的集成结构实际操作为，将父类的存储属性拷贝到子类当中(这里点类似C++)
        // classInfo部分实际上是虚表地址(方法列表)
        // retainCount是引用计数器
    }
    test_memory()
    
    // 2.重写下标、方法
    func test_override_method_subscript() {
        class Animal {
            func speak() {
                print("Animal obj speak")
            }
            
            class func speak() {
                print("Animal speak")
            }
            
            subscript(index: Int)->Int { 10 }
        }
        
        class Dog: Animal {
            override func speak() {
                super.speak()
                print("Dog obj speak")
            }
            
            override class func speak() {
                super.speak()
                print("Dog speak")
            }
            
            override subscript(index: Int) -> Int { super[index] + 20 }
        }
        
        print("类方法重写-------")
        Animal.speak()
        Dog.speak()
        
        print("实例方法重写-------")
        let a = Animal()
        let d = Dog()
        a.speak()
        d.speak()
        
        print("下标方法重写-------")
        print("---->\(a[0])")
        print("---->\(d[0])")
    }
    test_override_method_subscript()
    
    // 3.重写实例属性
    // 无论父类是存储类型还是计算类型，在子类中重写都职能重写为计算类型
    // 如果是类属性
    //      calss修饰的计算属性可以被子类重写(class只能在类中声名计算属性)
    //      static修饰的存储和计算属性都不可以被子类重写
    //
    // 注意：我们都知道，属性观察期和计算属性不能共存(set、get与willSet、didSet)
    //      但是可以将父类中的计算属性，在子类中重写添加观察器，也可以重写观察器
    func test_override_property() {
        class A {
            var x: Int = 10
            var y: Int {
                set { x = newValue / 2 }
                get { x * 2 }
            }
            
            static var z = 10
            class var z1: Int {
                set {  }
                get { 10 }
            }
            var f: Int = 10
            var f1: Int {
                set {  }
                get { 10 }
            }
            var f2: Int = 10 {
                willSet {}
                didSet {}
            }
        }
        
        class SubA: A {
            override var x: Int {
                set { super.x = newValue > 0 ? newValue : 0 }
                get { super.x }
            }
            override var y: Int {
                set { super.y = newValue / 3 }
                get { super.y * 3 }
            }
            
            override var f: Int {
                willSet {}
                didSet {}
            }
            override var f1: Int {
                willSet {}
                didSet {}
            }
            override var f2: Int {
                willSet {}
                didSet {}
            }
            
        }
        
        // 重写子类观察器，父类观察器也会被调用
        class B {
            class var x: Int {
                set { print("B set") }
                get { print("B get"); return 10}
            }
        }
        class SubB: B {
            override class var x: Int {
                willSet { print("B willSet \(newValue)") }
                didSet { print("B didSet \(oldValue), \(x)") }
            }
        }
        SubB.x = 30
        /**
         B get
         SubB willSet 30
         B set
         B get
         SubB didSet 10, 10
         // 后边4个步骤容易理解，主要是第一步，原因是需要先获取到x变量的地址，所以预先getter
         */
    }
    test_override_property()
    
    // final
    func test_final() {
        // 被final修饰的类、方法、下标、属性，禁止被重写
        /** 类
         final class A {}
         class SubA : A {}
         */
        
        class A {
            final var x: Int = 10
            final var y: Int {
                set {}
                get {10}
            }
            final class var z: Int {
                set {}
                get {10}
            }
        }
        class SubA : A {
            // 都不能重写
        }
    }
    test_final()