初學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 }