Swift－继承、重写

继承、重写

/*
 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）
 */