IOS系列swift语言之课时四

今天我们要讲的主要有：下标、可为空的类型、枚举（特殊的枚举：递归枚举）、原生值、关联值

首先来分析一下这个下标，就是说我们可以通过下标找到对应的值或者是改变对应的值。

　　　　其次是可为空的类型，我们要牢记所有类型默认不能为nil.

　　　　　　　　枚举的定义：可以一个case对应一个属性，也可以一个case对应多个属性，但是属性和属性之间用逗号隔开,注意中英格式

　　　　　　　　　第一种方式： enum Gender{

　　　　　　　　　　　　　　　　　　　　case Male

　　　　　　　　　　　　　　　　　　　　case Female

　　　　　　　　　　　　　　　　}

　　　　　　　　第二种方式： enum Week{

　　　　　　　　　　　　　　　　　　　　case Mon,Tue,Wed,Thi,Fir,Sat,Sum

　　　　　　　　　　　　　　}

　　　　　　下面就是原生值，其实很好理解就是由第一个赋了初始值，然后其他的就会按照规律改变，下面可以见案例.

　　　　　　　　　　关联值：每一个case可以关联不同类型的数据，而且每个case关联的都可能不一样

 1 mport UIKit
 2 /****下标***********************/
 3 class Teacher {
 4     var students = ["a","b","c"]
 5     
 6     subscript(i: Int) ->String  {
 7         get{
 8             return students[i]
 9         }
10         set(nv) {
11             students[i] = nv
12         }
13         
14     }
15     
16 }
17 
18 let t = Teacher()
19 t[0]
20 t[1] = "bbbb"
21 t[1]
22 //下标参数可以有多个，每个参数的类型也可以不一样

 1 /*  可为空的类型  */
 2 
 3 //var t1: Teacher = nil
 4 //在swift中，所有的类型，默认都不能赋值为nil
 5 //不管是值类型还是引用类型
 6 
 7 
 8 //swift对nil（null）进行了集中统一的管理
 9 //有点类似于一个包装
10 
11 //在类型后面添加一个？就表示这个类型是一个可为nil的类型
12 var a: Int?   = nil
13 
14 //包装类型不是被包装类型，是一个全新的类型，
15 //跟被包装类型可以认为没有任何的关系
16 
17 //wrapper
18 //class Nullable<T> {
19 //    var p: T
20 //    var p2 = nil
21 //}
22 a = 5
23 a = nil
24 a
25 a = 6
26 a!
27 if let b = a  {
28     
29 }

 1 /********** 枚举    *////////////
 2 
 3 enum Gender {
 4     case Male
 5     case Female
 6 }
 7 
 8 enum Week {
 9     case Monday,Tue,Wed,Thi,Fir,Sat
10     case Sun
11 }
12 let w = Week.Sun
13 let g = Gender.Male
14 switch g {
15 //case Gender.Female:
16 //    print("nv...")
17     
18 //default:
19 //    print("nan")
20     
21     case .Female:
22         print("nv...")
23     case .Male:
24         print("nan...")
25 }

 1 //原生值（Raw Value）
 2 
 3 //原生值类型只能是字符类型（CHaracher，string，）和数字类型
 4 enum FirstEnum: Int {
 5     case a = 15,b,c,d
 6 }
 7 
 8 let fe = FirstEnum.a
 9 fe.rawValue
10 
11 let f3 = FirstEnum(rawValue: 17)
12 f3
13 f3?.rawValue

 1 //关联值(Associative Value)
 2 //每个case可以关联多个不同类型的数据
 3 //也不需要每个case关联的类型是一样的。
 4 enum TiaoXingMa {
 5     case YiWei(Int,Int)
 6     case ErWei(String)
 7 }
 8 
 9 var txm = TiaoXingMa.YiWei(9, 1234)
10 
11 txm = .ErWei("asdfasdfasfd")

  1 //递归枚举（recusive enum）
  2 
  3 indirect enum DiGui {
  4     case A
  5     case B(Int)
  6     case C(DiGui)
  7 }
  8 let dga = DiGui.A
  9 
 10 var dg = DiGui.A
 11 
 12 dg = .B(555)
 13 //dg = .C(DiGui.A)
 14 dg = .C(dga)
 15 
 16 
 17 //7 * (8+9)
 18 //7*8 + (9*4)
 19 indirect enum SuanShuBiaoDaShi {
 20     case ShuZi(Int)
 21     case Jia(SuanShuBiaoDaShi,SuanShuBiaoDaShi)
 22     case Cheng(SuanShuBiaoDaShi,SuanShuBiaoDaShi)
 23 }
 24 //7 * (8+9)  // 1+2 * 3+5*8 +4*5
 25 let exp8 = SuanShuBiaoDaShi.ShuZi(8)
 26 let exp7 = SuanShuBiaoDaShi.ShuZi(7)
 27 let exp9 = SuanShuBiaoDaShi.ShuZi(9)
 28 
 29 let exp8jia9 = SuanShuBiaoDaShi.Jia(exp8, exp9)
 30 let exp7cheng8Jia9 = SuanShuBiaoDaShi.Cheng(exp7, exp8jia9)
 31 
 32 
 33 func yunsuan(exp: SuanShuBiaoDaShi) -> Int {
 34     
 35     switch exp {
 36     case .ShuZi(let num):
 37         return num
 38     case let .Jia(left, right):
 39         return yunsuan(exp: left) + yunsuan(exp: right)
 40     case  .Cheng(let left, let right):
 41         return yunsuan(exp: left) * yunsuan(exp: right)
 42 
 43     }
 44     
 45 }
 46 
 47 let result = yunsuan(exp: exp7cheng8Jia9)
 48 result
 49 
 50 
 51 //算出3+2
 52 //算出5*3
 53 //算出（1+2）*（3+4）
 54 
 55 //算出自然数的和
 56 //func add(max: int)->int  
 57 //从1开始，max假设为2 结果就是1+ 2
 58 //如果max 为10 加过1+2+3.。。。+10
 59 //1构建一个类。来实现刚才的功能
 60 
 61 //class Person {
 62 //    var name = "meiyouminzi"
 63 //    var shangSi: Person?
 64 //}
 65 //
 66 //let ceo = Person()
 67 //ceo.name = "chenjun"
 68 //
 69 //let lieyuanjun = Person()
 70 //lieyuanjun.name = "lieyuanjun"
 71 //lieyuanjun.shangSi = ceo
 72 
 73 //class Person {
 74 //    var name = "meiyoumingzi"
 75 //    var father: Person?
 76 //    var mother: Person?
 77 //}
 78 //let cj = Person()
 79 //cj.name = "cj"
 80 //let cjf = Person()
 81 //
 82 //cjf.name = "cjf"
 83 //let cjm = Person()
 84 //cjm.name = "cjm"
 85 //cj.father = cjf
 86 //cj.mother = cjm
 87 
 88 class Expression {
 89     var caozuofu = ""
 90     var shuzi = 0
 91     var left: Expression?
 92     var right: Expression?
 93     
 94     func yunsuan(exp: Expression) -> Int {
 95         
 96         switch exp.caozuofu {
 97         case "+":
 98             return yunsuan(exp: exp.left!) + yunsuan(exp:  exp.right!)
 99         case  "*":
100             return yunsuan(exp: exp.left!) * yunsuan(exp: exp.right!)
101         default:
102             return exp.shuzi
103         }
104         
105     }
106 
107 }
108 
109 let e7 = Expression()
110 e7.shuzi = 7
111 let e8 = Expression()
112 e8.shuzi = 8
113 let e9 = Expression()
114 e9.shuzi = 9
115 
116 let e89 = Expression()
117 e89.caozuofu = "+"
118 e89.left = e8
119 e89.right = e9
120 let e7mule89 = Expression()
121 e7mule89.caozuofu = "*"
122 e7mule89.left = e7
123 e7mule89.right = e89
124 
125 let rys = e7mule89.yunsuan(exp: e7mule89)
126 //let ys = Expression()
127 //let cys = ys.yunsuan(exp: (e7mule89))

以上就是简单的涉猎枚举，其实枚举的作用就是当我们调用的时候不记得了属性或者是打错了，它会有提示，而不至于我们都不知道自己错在哪里了.当然这只是我个人的理解！

　　　　最后面有几道题，需要的自己看一下.

　　　　　　　　迎新晚会要忙死了，估计都没什么午休和业余时间，尽量多发一些，I want to be fall asleep.