初学swift笔记 继承（十）

 import Foundation
 /*
 继承

 class childClass: FatherClass{

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

 只能单继承
 */
 class Human{
     var name: String=""
     var id: Int=
     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 =  //存储属性
     var coputePreperty: Int{ //计算属性
         get{
             return
         }
         set{
             println("In Father Class Set \(newValue)")
         }
     }
     var coputePrepertys: Int{ //计算属性
         get{
             return
         }
     }
 }
 //重写的属性 呈现的是计算属性
 /*重写的限制，
 1.属性重写，父类如果有get set 子类重写后必须拥有get set
 2.不可以重写为只读的计算属性
 3.父类计算属性是只读的时候，子类可重写为只读、读写的计算属性

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

 }