初学swift笔记 继承（十）

  1 import Foundation
  2 /*
  3 继承
  4 
  5 class childClass: FatherClass{
  6 
  7 }
  8 优点 代码重用
  9 缺点 增加程序的藕合度 父类的改变会影响子类
 10 
 11 只能单继承
 12 */
 13 class Human{
 14     var name: String=""
 15     var id: Int=0
 16     func eat(){
 17         println("吃饭")
 18     }
 19     func drink(){
 20         println("喝水")
 21     }
 22     func sleep(){
 23         println("睡觉")
 24     }
 25 }
 26 class Woman : Human {
 27     
 28     func birth(){
 29         println("birth")
 30     }
 31 }
 32 
 33 let w_woman = Woman()
 34 w_woman.eat()
 35 w_woman.name="aaa"
 36 
 37 //super关键字  派生类中的方法实现中，可以通过super关键字来引用基类的属性和方法
 38 
 39 class LSQ : Human{
 40     func eatAndSleep(){
 41         super.eat() //用super修饰此方法 ，告诉编译器到当前类的父类去查找。表示调用父类的方法
 42         sleep()
 43         say()
 44     }
 45     func say(){
 46         println("hello")
 47     }
 48 }
 49 //方法 属性重写 override关键字
 50 class LSQ1 : Human{
 51     func eatAndSleep(){
 52         super.eat() //调用父类方法
 53         super.sleep()
 54     }
 55     override func eat() {//重写父类方法
 56         println("LSQ1 eat")
 57     }
 58     
 59 }
 60 
 61 let lsq_1 = LSQ1()
 62 lsq_1.eatAndSleep()
 63 lsq_1.eat()
 64 
 65 class  Father{
 66     var storePreperty: Int = 0 //存储属性
 67     var coputePreperty: Int{ //计算属性
 68         get{
 69             return 0
 70         }
 71         set{
 72             println("In Father Class Set \(newValue)")
 73         }
 74     }
 75     var coputePrepertys: Int{ //计算属性
 76         get{
 77             return 0
 78         }
 79     }
 80 }
 81 //重写的属性 呈现的是计算属性
 82 /*重写的限制，
 83 1.属性重写，父类如果有get set 子类重写后必须拥有get set
 84 2.不可以重写为只读的计算属性
 85 3.父类计算属性是只读的时候，子类可重写为只读、读写的计算属性
 86 
 87 属性权利可以放大，不可以减小
 88 */
 89 class Child: Father {
 90     //将父类的存储属性重写为计算属性,不可以将存储属性重写成存储属性
 91     override var storePreperty : Int { //重写了父类的存储属性
 92         get{
 93             return 10
 94         }
 95         set{
 96             println("In Child Class Set \(newValue)")
 97         }
 98     }
 99     //父类的计算属性，重写为计算属性 ，不可以重写为存储属性
100     override var coputePreperty : Int{
101         get{
102             return 90
103         }
104         set{
105             println("child coputePreperty")
106         }
107     }
108     //重写只读的计算属性
109     override var coputePrepertys : Int{
110         get{
111             return 90
112         }
113         set{
114             println("child coputePreperty")
115         }
116     }
117 }
118 
119 var test = Child()
120 println(test.storePreperty)
121 
122 
123 /*
124 重写 属性观察器
125 1.只能给非lazy属性的变量存储属性设定属性观察器，不能给计算属性设定属性观察器
126 2.父类属性必须是可读写的，否则不能重写属性观察器
127 */
128 class myF{
129     var name: String = ""  {
130         willSet{
131             println("修改前\(newValue)")
132         }
133         didSet{
134             println("修改后\(oldValue)")
135         }
136     }
137     
138 }
139 class my_a: myF{
140     override var name : String {
141         willSet{
142             println("重写修改前\(newValue)")        }
143         didSet{
144             println("重写修改后\(oldValue)")
145         }
146     }
147     func getname() -> String {
148         return super.name
149     }
150 }
151 //重写了属性观察器，并没有重写存储属性
152 var my_z = my_a()
153 my_z.name="LSQ"
154 println(my_z.name)
155 println(my_z.getname())
156 
157 /*
158 防止重写
159 关键字 final
160 修饰类 表示 类不可以被继承
161 修饰属性或方法，表示相应的属性或方法不能被重写
162 */
163  class Test_Father{
164   final  var name: String = "abc"
165     final func getName(){
166         println("getName")
167     }
168 }
169 
170 class Test_child: Test_Father {
171   //  override var name: String = "a"  //报错，不可以重写
172     // override func getName(){} //报错，不可以重写
173 
174     
175 }