1 import Foundation 2 /* 3 和类很相似 4 5 结构体 －> 封装 6 属性、方法 7 结构体是值类型 8 */ 9 10 //定义一个LSQ类型的结构体 关键字struct 11 struct LSQ { 12 var Name: String = "" 13 var Age: Int = 1 14 } 15 struct LSQ1 { 16 var Name: String 17 var Age: Int 18 } 19 struct LSQ2 { 20 var Name: String 21 var Age: Int=1 22 } 23 24 //结构体实例和属性访问 25 //声明一个变量 26 var liu : LSQ = LSQ() 27 var liu1 : LSQ1 = LSQ1(Name: "liuq", Age: 18) 28 liu.Age=19 29 liu.Name="zhong" 30 31 liu1.Name="ha" 32 liu1.Age=20 33 34 println(liu1.Name) 35 println(liu.Name) 36 var liu2 : LSQ2 = LSQ2(Name:"AA",Age:1) 37 println("\(liu2.Age):\(liu2.Name)") 38 39 //定义带有函数的结构体 40 struct m_lsq_1 { 41 42 var Name : String = "" 43 var Age : Int = 1 44 func getName() -> String { 45 return Name 46 } 47 } 48 49 var temp1 = m_lsq_1(Name: "王建国", Age:30) 50 println(temp1.getName()) 51 52 53 //结构体是值类型 不是引用类型 54 var temp2=temp1 55 println(temp2.getName()) 56 temp2.Name="TempName" 57 println(temp2.getName()) 58 59 60 61 /* 62 类 63 属性、方法 64 类是引用类型 65 66 class 类名 ｛ 67 成员变量 68 成员方法 69 ｝ 70 */ 71 //定义一个类 72 class m_class_1 { 73 func m_class_1() { 74 Name="m_Name" 75 Age=1 76 } 77 var Name : String = "" 78 var Age : Int = 0 79 } 80 //引用类型 81 var class_1 = m_class_1() 82 83 println(class_1) 84 85 var class_2 = class_1 86 87 println(class_2) 88 89 //当需要判断多个常量或变量是否是同一个实例时 用 === 恒等于 !== 不等于 判断 90 if class_1 === class_2 { 91 println("相同") 92 } 93 94 /* 95 常量 结构体、枚举 是值类型， 常量不可修改，其属性不可修改 96 常量 类类型，是引用类型，常量不可修改，其属性可以修改 97 */ 98 //存储属性 99 //结构体存储属性 100 struct person { 101 var name : String //变量存储属性 102 let sex : String = "男" //常量存储属性 103 } 104 105 var m_p = person(name: "lsq", sex: "男") 106 //常量属性不可修改 107 println(m_p.sex) 108 let m_p_1 = person(name: "t", sex: "n") 109 //m_p_1.name="lsq" // m_p_1是一个常量，其属性不可修改 110 111 //类存储属性 112 class c_person { 113 var name : String = "" //变量存储属性 114 let sex : String = "男" //常量存储属性 115 } 116 let c_p = c_person() //c_p 是一个常量，其属性可修改 117 c_p.name="lsq" 118 println(c_p.name) 119 120 let c_p1 = c_person() 121 // c_p = c_p1 //类常量不可修改 122 123 //延迟存储属性 124 //swift中所有的存储属性必须有初始值，也就是当构造完一个类或结构体对象后，对象中所有的存储属性必须有初始值，但有例外，其中延迟存储属性可以将属性的初始化向后推迟到该属性第一次使用时赋值 关键字lazy 125 //使用延迟属性：1.属性不适合一开始就初始化，取决于外部对很多因素 2.属性有可能从来都不用，但是它对初始化会需要很长时间 126 //学生结构体 127 struct student { 128 var name : String 129 var age : Int 130 func get_name() { 131 println("我的姓名是:\(name)") 132 } 133 } 134 //班级类 135 class my_class { 136 var members : [student] = [] 137 lazy var score : Double = self.getScore() //延迟属性 lazy关键字 score的值是 getScore（）结果 当访问score时才去调用方法 138 //计算平均值 139 func getScore() -> Double { 140 var t: Double = 0 141 for i in members { 142 t += Double(i.age) 143 } 144 if members.count > 0 { 145 return t / Double(members.count) 146 } 147 return 0 148 } 149 //显示所有name 150 func show () { 151 for i in members { 152 println(i.name) 153 } 154 } 155 func show_1() { 156 for i in members { 157 i.get_name() 158 } 159 } 160 161 } 162 //常规用法 163 var s1 = student(name: "小明", age: 8) 164 var s2 = student(name: "小红", age: 10) 165 var c1 = my_class() 166 c1.members.append(s1) 167 c1.members.append(s2) 168 c1.show() 169 c1.show_1() 170 println(c1.getScore()) 171 172 //使用延迟属性 173 var c2 = my_class() 174 c2.members.append(s1) 175 c2.members.append(s2) 176 println(c2.score) 177 178 179 /* 180 计算属性 181 1.计算属性不直接存储其值，与存储属性不同，没有任何后端存储与之对应 182 2.计算属性用于计算，可以实现setter和getter 两种计算方法 183 3.枚举不可以有存储属性，但是允许有计算属性 184 对象.属性 ＝ 某值 setter 185 let value = 对象.属性 getter 186 个人理解：与c#中的get set 相似，对象存放结果，每次获取结果需要计算 187 swift中的计算属性，不可以直接存储任何的值。 188 189 只读属性 如果计算属性只提供了get 没有提供set那么该属性是只读属性 190 */ 191 192 struct m_rect { 193 var origion: (x: Double,y: Double) = (0,0) 194 var size: (w: Double,h: Double) = (0,0) 195 //size是计算属性，不能直接赋值， 196 var center : (x: Double,y: Double) { 197 get { 198 //获取的值是重新计算的 199 return (origion.x + size.w/2 , origion.y + size.h/2) 200 } 201 set(n) { 202 //赋值的时候直接给 origion赋值 203 origion.x = n.x - size.w/2 204 origion.y = n.y - size.h/2 205 //origion.x = n.0 - size.w/2 206 //origion.y = n.1 - size.h/2 207 } 208 /* 209 当不指定n的时候，默认写法是 newValue 表示要赋的值 210 set { 211 //赋值的时候直接给 origion赋值 212 origion.x = newValue.x - size.w/2 213 origion.y = newValue.y - size.h/2 214 } 215 */ 216 } 217 } 218 219 var rect = m_rect() 220 rect.size = (100,100) 221 println(rect.origion) 222 rect.center = (12 ,23) 223 println(rect.origion) 224 225 226 /* 227 计算只读属性 228 如果计算属性只提供了get 没有提供set那么该属性是只读属性 229 230 */ 231 //学生结构体 232 struct student_1 { 233 var name : String 234 var age : Int 235 func get_name() { 236 println("我的姓名是:\(name)") 237 } 238 } 239 //班级类 240 class my_class_1 { 241 var members : [student_1] = [] 242 lazy var score : Double = self.getsum() //延迟属性 243 //计算属性 只读属性 只提供了get方法 244 var allage : Double { 245 246 get{ 247 return getsum() 248 } 249 } 250 //只读计算属性的简写 省略 get关键字 251 var allages : Double { 252 return getsum() 253 } 254 func getsum() -> Double { 255 var t: Double = 0 256 for i in members { 257 t += Double(i.age) 258 } 259 return t 260 } 261 262 } 263 var c3 = my_class_1() 264 c3.members.append(student_1(name: "小明", age: 8)) 265 c3.members.append(student_1(name: "小红", age: 10)) 266 println(c3.allage) 267 268 269 /* 270 属性观察器 271 当类中的属性或方法的某个值发生了变化，则调用指定的方法 在OC中称之为KVO 272 willSet 修改前被调用 273 didSet 属性被修改之后调用 274 相当于注册了两个事件 275 276 */ 277 class my_class_3 { 278 var t_value : Double = 0{ 279 willSet { 280 println("WillSet调用:\(newValue)") 281 } 282 didSet { 283 println("didSet调用:\(oldValue)") 284 } 285 } 286 287 } 288 var m_3 = my_class_3() 289 m_3.t_value = 1 290 291 //类型属性 可以理解为静态变量 292 //在结构体中用static关键字修饰 在class类中用class关键字修饰 293 struct type_property { 294 var property : Int = 0 295 //类型属性， 该变量属于当前类的 ，与其他语言中的静态变量相似 不同的是访问该变量时 只能通过类名.出该变量 所有实例化该类的对象共用此变量 296 static var static_property : Int = 0 297 } 298 var obj = type_property() 299 obj.property = 10 300 type_property.static_property = 10