初学swift笔记 继承（十）

import Foundation
/*
继承

class childClass: FatherClass{

}
优点 代码重用
缺点 增加程序的藕合度 父类的改变会影响子类

只能单继承
*/
class Human{
    var name: String=""
    var id: Int=0
    func eat(){
        println("吃饭")
    }
    func drink(){
        println("喝水")
    }
    func sleep(){
        println("睡觉")
    }
}
class Woman : Human {
    
    func birth(){
        println("birth")
    }
}

let w_woman = Woman()
w_woman.eat()
w_woman.name="aaa"

//super关键字  派生类中的方法实现中，可以通过super关键字来引用基类的属性和方法

class LSQ : Human{
    func eatAndSleep(){
        super.eat() //用super修饰此方法 ，告诉编译器到当前类的父类去查找。表示调用父类的方法
        sleep()
        say()
    }
    func say(){
        println("hello")
    }
}
//方法 属性重写 override关键字
class LSQ1 : Human{
    func eatAndSleep(){
        super.eat() //调用父类方法
        super.sleep()
    }
    override func eat() {//重写父类方法
        println("LSQ1 eat")
    }
    
}

let lsq_1 = LSQ1()
lsq_1.eatAndSleep()
lsq_1.eat()

class  Father{
    var storePreperty: Int = 0 //存储属性
    var coputePreperty: Int{ //计算属性
        get{
            return 0
        }
        set{
            println("In Father Class Set \(newValue)")
        }
    }
    var coputePrepertys: Int{ //计算属性
        get{
            return 0
        }
    }
}
//重写的属性 呈现的是计算属性
/*重写的限制，
1.属性重写，父类如果有get set 子类重写后必须拥有get set
2.不可以重写为只读的计算属性
3.父类计算属性是只读的时候，子类可重写为只读、读写的计算属性

属性权利可以放大，不可以减小
*/
class Child: Father {
    //将父类的存储属性重写为计算属性,不可以将存储属性重写成存储属性
    override var storePreperty : Int { //重写了父类的存储属性
        get{
            return 10
        }
        set{
            println("In Child Class Set \(newValue)")
        }
    }
    //父类的计算属性，重写为计算属性 ，不可以重写为存储属性
    override var coputePreperty : Int{
        get{
            return 90
        }
        set{
            println("child coputePreperty")
        }
    }
    //重写只读的计算属性
    override var coputePrepertys : Int{
        get{
            return 90
        }
        set{
            println("child coputePreperty")
        }
    }
}

var test = Child()
println(test.storePreperty)


/*
重写 属性观察器
1.只能给非lazy属性的变量存储属性设定属性观察器，不能给计算属性设定属性观察器
2.父类属性必须是可读写的，否则不能重写属性观察器
*/
class myF{
    var name: String = ""  {
        willSet{
            println("修改前\(newValue)")
        }
        didSet{
            println("修改后\(oldValue)")
        }
    }
    
}
class my_a: myF{
    override var name : String {
        willSet{
            println("重写修改前\(newValue)")        }
        didSet{
            println("重写修改后\(oldValue)")
        }
    }
    func getname() -> String {
        return super.name
    }
}
//重写了属性观察器，并没有重写存储属性
var my_z = my_a()
my_z.name="LSQ"
println(my_z.name)
println(my_z.getname())

/*
防止重写
关键字 final
修饰类 表示 类不可以被继承
修饰属性或方法，表示相应的属性或方法不能被重写
*/
 class Test_Father{
  final  var name: String = "abc"
    final func getName(){
        println("getName")
    }
}

class Test_child: Test_Father {
  //  override var name: String = "a"  //报错，不可以重写
    // override func getName(){} //报错，不可以重写

    
}