1 //MARK:-----------------控制流-----------------
2 //MARK: 1.for - in 循环 ,不用声明Value类型
3
4 //for value in 1...6 {
5 //print(value)
6 //
7 //}
8
9
10 //不需要具体的值，只是为了得到循环次数
11
12 //for _ in 1...6 {
13 //print("123")
14 //}
15
16
17 //MARK: 2.for循环，和C一样，只是没有 括号
18
19 //for var i = 0 ; i < 26 ; i++ {
20 //print("i = \(i)")
21 //}
22
23 //MARK: 3.while 循环,和C一致
24
25 //var whileValue = 0
26 //while whileValue < 10 {
27 // whileValue++
28 //
29 // print("while ++ -- \(whileValue)")
30 //}
31
32
33 //MARK: 4. do-while 循环
34
35 //var number = 0
36
37 //repeat {
38 //print("number -- \(number)")
39 //number++
40 //}while false
41
42 //repeat {
43 // print("number -- \(number)")
44 // number++
45 //}while number < 10
46
47 //MARK: 5. if-else 语句，分支语句
48 //var applePrice = 8.5 // double
49 //
50 //if applePrice < 5 {
51 //
52 // print("applePrice -- \(applePrice)")
53 //}else{
54 // print("applePrice -- \(applePrice)")
55 //}
56
57
58 //MARK: if-else语句 的值绑定 可以保护程序
59
60 //var optionValue :Int?
61 //var optionValue :Int? = 5
62 //if var tempOptionValue = optionValue {
63 // //如果可选类型有值，就走条件成立的语句
64 //print("value = \(tempOptionValue)")
65 //}else{
66 // //如果没有值，就走条件不成立的语句
67 // print("可选类型为nil")
68 //}
69
70
71
72 //MARK: 6.witch - case
73 //（1）Swift中没有自动贯穿，即使把break删掉，也不会贯穿达下个case语句
74 //（2）有需要贯穿需求的时候，需要加贯穿语句 fallthrough
75 //（3）如果case中，没有任何语句，就必须加break ，没有语句就不必加break
76 //（4）如果不写default，case语句必须包含所有情况。否则必须写。
77 //var switchValue = 11
78 //switch switchValue {
79 //case 10:
80 // print("10")
81 //// break
82 //case 11:
83 // print("11")
84 //// break
85 //
86 // fallthrough
87 //case 12:
88 // print("12")
89 //// break
90 //default:
91 // print("other")
92 //
93 //}
94
95 //MARK: switch -case 的值绑定
96 //当case条件满足时，进入case语句，把值赋给我们设的局部变量（常量）
97 //var (x,y) = (0,10)
98 //switch (x,y){
99 //case (let localX,0):
100 // print("localX = \(localX)")
101 //case (0,let localY):
102 // print("localY = \(localY)")
103 //default:
104 // print("other")
105 //}
106
107 //MARK: switch-case的区间匹配
108
109 //var money : Float = 10.5
110 //switch money {
111 //case 0...10:
112 // print("穷屌丝")
113 //case 10...100 :
114 // print("普通人")
115 //default:
116 // print("高富帅")
117 //}
118
119
120
121 /* 词语辨析
122 fallthrough ：贯穿
123 continue :结束本次循环，进入下次循环
124 break：跳出循环
125 */
126
127
128 //MARK: 7.标签语
129 //sign: 主要用于循环嵌套：可以给循环加标签，这样可以给指定循环做一些操作.作用：更易于操作循环
130 //sign:while true {
131 //
132 // for var i = 0 ; i < 10 ; i++ {
133 //// 指定break是那个控制流
134 // if i == 5 {
135 // break sign
136 // }
137 // print("i -- \(i)")
138 // }
139 //}
140
141
142 //MARK: ----------------函数---------------------
143 //MARK: ----函数调用 --
144
145 /*
146 func 函数名(参数列表) ->返回值 {
147 //实现动作部分
148 }
149
150 */
151
152 //func 函数名()->返回值
153 //MARK: 1.无参无返回值 , 没有返回值可以不写 ->154
155 //func printFunc(){
156 //
157 //}
158
159
160 //func printFunc()->Void {
161 // print("123")
162 //}
163
164 ////diaoyong hanshu
165 //printFunc()
166
167 //MARK: 2.有参无返回值
168 //func printCity(cityName:String){
169 //print("城市--\(cityName)")
170 //}
171 //
172 ////调用函数
173 //printCity("郑州")
174
175
176 //MARK: 3.无参有返回值
177 //func returnString()->String{
178 //return "北京"
179 //}
180 //
181 //let string = returnString()
182 //
183 //print(string)
184 //
185 //print(returnString())
186
187
188 //MARK: 4.有参有返回值 :可以支持多个返回值
189
190 func matchFun(number1:Int,number2:Int)->(Int,Int){
191
192 // number1++
193 return (number1 + number2,number2 * number1)
194 }
195
196 //print(matchFun(2, number2: 3))
197
198
199 /*注意事项：
200 1.函数的形参是let类型（常量），而不是变量（变量）；用var修饰形参可改变
201 2.交换两个数
202
203 */
204
205 //1.
206 func changeCity(var loveCityName:String){
207
208 loveCityName = "北京"
209 // print(loveCityName)
210 }
211
212 changeCity("上海")
213
214 //2.交换两个数
215 //函数中任意改变形参，实参不会变
216 //MARK: 注意：要改变实参，需要传进入地址（&）,需要inout关键字---
217 func changeTwoNumber(inout number1 :Int,inout number2 :Int)->(Int,Int){//（1）
218
219 //func changeTwoNumber(var number1 :Int,var number2 :Int)->(Int,Int){//（2）
220
221 let tempNumber = number1;
222 number1 = number2;
223
224 number2 = tempNumber;
225
226
227 return (number1,number2)
228 }
229
230 var a = 1,b = 2
231
232 let (x,y) = changeTwoNumber(&a, number2: &b)//（1）
233 //let (x,y) = changeTwoNumber(a, number2: b)//（2）
234
235 //print((x,y))
236 //print("a- \(a),b - \(b)")
237
238
239
240 //MARK: 给函数添加一个外部形参名，作用：在函数调用时，可以看到
241
242 //func travelCity( cityName1:String,CityName:String, cityName3:String){//(1)
243
244 func travelCity(firstCity cityName1:String,sencondCity CityName:String,thirdCity cityName3:String){//(2)
245
246 //print("我的旅行路线\(cityName1)-->\(CityName)-->\(cityName3)")
247 }
248
249
250 //调用
251
252 //travelCity("北京", CityName:"马尔代夫", cityName3: "巴黎")//(1)
253 travelCity(firstCity: "北京", sencondCity: "马尔代夫", thirdCity: "巴黎")//(2)
254
255 // 简化的外部参数名：( 只需要在第一个参数名前加外部参数)
256 func travelCity1(cityName1 cityName1:String, CityName:String, cityName3:String){//(2)
257
258 // print("我的旅行路线\(cityName1)-->\(CityName)-->\(cityName3)")
259 }
260
261 //调用
262 //travelCity1(cityName1: <#T##String#>, CityName: <#T##String#>, cityName3: <#T##String#>)
263
264
265 //MARK:-----------------函数类型-----------------
266 //MARK:1.函数类型是由，函数的参数和返回值组成
267
268 func addFunc(number1 number1:Int,number2:Int) -> Int{
269 return number1 + number2
270 }//这个函数的类型就是 （Int,Int） ->Int
271
272
273
274 //MARK:2.定义函数类型的变量：类似typeDef
275 //var tongVar :String = "string"
276
277 var tongVar :(Int,Int)->Int = addFunc
278
279 //print(tongVar(3,4))
280
281
282 //MARK:3.将函数作为参数
283 //把addFunc2作为另一个函数的参数
284 func addFunc2(number1 number1:Int,number2:Int) -> Int{
285 return number1 + number2
286 }
287
288 //参数1- 参数名：match 参数类型：(Int,Int)->Int
289 //参数2- 参数名：number1 参数类型：Int
290 //参数3- 参数名：number2 参数类型：Int
291
292 //func ParaFunc(match match:(Int,Int)->Int,number1:Int,number2:Int){
293 // let resultNumber1 = match(number1,number2);
294 // print(resultNumber1)
295 //}//(1)
296
297 func ParaFunc(addFunc2 addFunc2:(Int,Int)->Int,number1:Int,number2:Int){
298
299
300 // print(addFunc2(number1,number2))
301 }//(2)
302
303 //调用
304
305 //ParaFunc(match: addFunc2, number1: 2, number2: 4)//(1)
306
307 ParaFunc(addFunc2: addFunc2, number1: 2, number2: 4)//(2)
308
309
310 //MARK:4函数作为返回值，返回值是一个函数类型
311
312 func mutiFun2(number1 number1:Int,number2:Int)->Int{
313 return number1 * number2
314 }
315
316 //定义一个函数，返回值类型是（Int，Int）->Int
317 //参数名：add 类型：Bool 返回值类型：(Int,Int)->Int
318 func selectFunc(isSelectAddFun add:Bool)-> ((Int,Int)->Int){
319
320
321 return add ? addFunc2 :mutiFun2;
322 }
323
324 let result = selectFunc(isSelectAddFun: false)//result 就是函数类型，即(Int,Int)->Int
325
326
327 //print(result(1,2))
328 //
329 //print(selectFunc(isSelectAddFun: true)(1,2))
330
331 //MARK：函数的嵌套
332 //func emedFun(judge judge:Bool,number:Int){
333 // //自增函数
334 // func addNumber(var number1:Int){
335 // print(++number1)
336 // }
337 // //自减函数
338 // func jianNumber(var number2:Int){
339 // print(--number2)
340 // }
341 // // 利用bool值去判断，调用自增还是自减
342 // let funcName = judge ? addNumber :jianNumber
343 // // 利用参数number去调用自增或者自减
344 // funcName(number)
345 //}
346
347 //调用
348
349 //emedFun(judge: false, number: 1)//在函数外层调用，对应只能调用函数外层
350
351
352 //MARK: 重点------闭包------
353 //类似OC中的block
354 //定义一个闭包
355 var block = { (str:String)-> Void in
356 // block块
357 // print(str)
358
359 }
360
361 //调用闭包
362 block("我爱北京天安门")
363
364
365 //MARK:-----------------枚举-----------------
366 /*
367 //1.枚举名首字母大写，枚举值首字母也大写
368 //2.swift的枚举和C的区别
369 2.1有case关键字
370 2.2枚举值有哈希值
371 */
372
373 /*
374 enum City{
375 case beijing
376 case Paris
377 case NewYork
378 }
379 print(City.NewYork.hashValue)
380
381 //3.原始值和rawValue
382
383 enum PoneType :String{
384 case Apple = "IPhone"
385 case MI = "Mi4"
386 // case HUAWEI = "荣耀"
387 case HUAWEI
388 }
389
390 print(PoneType.HUAWEI.rawValue)//如果有rawValue就会打印，否则打印case后枚举值
391
392
393 //通过rawValue找到对应的枚举值
394 var ii = PoneType(rawValue: "荣耀")
395
396 /*
397 //print(ii!.rawValue)//强制解析
398 print(ii?.rawValue)//可选解析
399 print(ii)//默认为可选解析
400 */
401
402
403 */
404
405
406 //MARK:相关值
407 //利用枚举的相关值结合switch-case进行值的绑定
408
409 enum Girl{
410 case Id(Int)
411 case Info(String,Int,Double)//姓名，年龄，身高
412 }
413
414 //进行值的绑定
415 /*
416 var girl = Girl.Info("貂蝉", 21, 165)
417
418 switch girl {
419 case Girl.Info(var girlName,var age,var height) :
420 print("name --\(girlName)")
421 case Girl.Id(var girlID):
422 print("ID -- \(girlID)")
423 }
424 */
425 //MARK:-----------------类-----------------
426
427 /*和OC区别：
428
429 1.运用class关键字
430 2.没有.h .m
431 3.在同一个括号内声明属性，书写方法
432
433 */
434
435 //定义一个类,关键字是Class，类名首字母大写
436 class Student {
437 //类的属性（实例变量）,属性名studentAge，类型Int
438 var studentAge :Int
439 var studentName:String
440 // 给属性添加init方法，目的为给属性一个默认值
441 init(studentAge:Int,studentName:String){//一个类只能有一个init方法
442 // 给属性赋默认值
443 self.studentAge = studentAge
444 self.studentName = studentName
445 }
446
447 //MARK:注意--类方法 （函数）
448 func printStu(){
449 print(self.studentAge,self.studentName)
450 }
451
452 // 有参数有返回值
453 func change(stuName:String)->String{
454 self.studentName = stuName
455 return self.studentName
456 }
457 }
458
459 //调用该类
460 //实例化一个类对象
461 let studentItem = Student(studentAge: 26, studentName:"我饿了")
462 //属性的设置和访问
463
464 studentItem.studentAge = 24;
465
466 //print(studentItem.studentAge)
467
468 //studentItem.printStu()
469
470 //print(studentItem.change("嗯哼"))
471
472
473 //MARK: ---结构体---
474 //定义一个结构体，关键字struct
475 //结构体不需要写init方法，因为它已经为我们写好了
476 struct GirlSTR {
477 //属性
478 var girlName:String
479 var girlHeight:Double
480
481
482 // 方法
483 func printFourBeautifulGirls(girlName1:String ,girlName2:String, girlNmae3:String){//注意‘,’不可少
484 print("四大美女---\(self.girlName) \(girlName1) \(girlName2) \(girlNmae3)")
485
486 }
487
488 func printHeith(){
489
490 print(self.girlHeight)
491 }
492 }
493
494 //实例化一个结构体
495
496 var girl = GirlSTR(girlName: "小笼包", girlHeight: 20)
497
498 //访问结构体的属性，设置结构体属性
499 //print(girl.girlName)
500 girl.girlHeight = 1.60
501 //girl.printHeith()
502 //girl.printFourBeautifulGirls("1", girlName2: "2", girlNmae3: "3")
503
504
505 //MARK:类和结构体的区别
506
507 //1.类是引用类型，结构体是值类型
508 var studentItem2 = studentItem;
509 studentItem.studentAge = 2
510
511 print(studentItem.studentAge,studentItem2.studentAge)
512
513
514 var girl2 = girl
515 girl.girlHeight = 1.20
516 print(girl.girlHeight,girl2.girlHeight)
517
518
519 //2.类可以继承，结构体不能继承（最本质）
520
521 //3.结构体对象如果是let类型即使属性是var类型也是不可修改的。类对象即使是let类型，属性如果是var类型也是可以修改的
522
523 //MARK:恒等运算 ===
524 //用来对两个类实例（对象）进行判断，到底是否完全一致
525
526 if studentItem2 === studentItem {
527 print("两个实例相等")
528
529 }else{
530 print("两个实例不相等")
531 }
时间： 2024-11-05 09:58:50