Swift－继承、重写

￡神魔★判官ぃ 2023-10-17 09:51 149阅读 0赞

继承、重写

/*
     1、继承语法
     继承是面向对象最显著的一个特征。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。
     术语：基类（父类，超类），派生类（子类，继承类）
     swift继承语法：
     class ChildClass:FatherClass{
     }
     继承优点：代码重用
     继承缺点：增加程序耦合度，父类改变会影响子类
     swift没有多继承（单继承，没有继承方式，相当于公有继承）
     */
    print("1、继承、super、override（重写）")
    class Human{
        var name:String = ""
        var id:Int = 0
        func eat(){
            print("eat")
        }
        func drink(){
            print("drink")
        }
        func sleep(){
            print("sleep")
        }
    }
    //没有继承方式，可看成公有继承
    class Woman: Human {
        func birth() {
            print("birth")
        }
        /*
         * override 重写关键字
         */
        override func eat() {
            super.eat()//一般super和override关键字配合使用
            print("woman eat")
        }
        //派生类中使用基类方法或者属性
        func eatAndSleep(){
            eat()//(从本类中开始查找方法)
            super.eat()//(从父类中查找方法)super关键字派生类中方法实现中，可以通过super关键字来引用基类的方法和属性
            sleep()
            birth()
        }
    }
    
    let h = Human()
    let w = Woman()
    h.name = "ming"
    h.id = 78997
    w.eat()
    w.drink()
    //w.eatAndSleep()
    //h.birth()
    print("w.name=\(w.name),w.id=\(w.id)")
    
    /*
     2、重写属性
     */
    print("\n2、重写属性")
    class Father {
        var storeProperty:Int = 0
        var coupteProperty:Int {
            get {
                return 0;
            }
            set {
                print("In Father Class:set\(newValue)")
            }
        }
    }
    class Child: Father {
        //可以将一个父类的存储属性重写成计算属性，不可以将存储属性又重写成存储属性
        override var storeProperty:Int{
            get{
                return 10
            }
            set{
                print("In Child Class:set storeProperty with value=\(newValue)")
            }
        }
        //可以将父类中的计算属性重写，重写的样式也是计算属性样式
        override var coupteProperty:Int{
            get{
                return 10
            }
            set{
                print("In Child Class:set coupteProperty with value=\(newValue)")
            }
        }
    }
    let child = Child()
    //通过子类的对象来调用重写后的属性或者方法，肯定会调用字类中的重写属性
    child.storeProperty = 100
    child.coupteProperty = 50
    
    /*
     3、重写属性限制
     （1）属性重写时set和get方法都必须要都有
     （2）可读写的计算／存储属性不可以重写为只读的计算属性（权力变小）
     （3）只读的计算／存储属性可以在重写时变为读写的计算属性（权力变大）
     */
    
    /*
     4、重写属性观察器
     （1）只能给非lazy属性的变量存储属性设定属性观察器，不能给计算属性设定属性观察器
      限制
     （1）不可以给只读的存储/计算属性，在子类中设定属性观察器
     */
    class Observer{
        final var stroeProperty:Int = 0
        var computeProperty:Int{
            get{
                return 0
            }
            set{
                print("Do nothing")
            }
        }
    }
    class ChildOfObserver: Observer {
    //    //可以重写父类中变量存储属性的属性观察器
    //    override var stroeProperty: Int{
    //        willSet{
    //            print("will set")
    //        }
    //        didSet{
    //            print("did set")
    //        }
    //    }
        //可以重写父类中的计算属性的属性观察器
        override var computeProperty: Int{
            willSet{
                print("compute will set")
            }
            didSet{
                print("compute did set")
            }
        }
    }
    let ob = ChildOfObserver()
    ob.computeProperty = 9
    ob.stroeProperty = 10
    
    /*
     5、防止重写（final）
     */