IOS系列swift语言之课时四

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

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

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

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

　　　　　　　　　第一种方式：  enum Gender{

　　　　　　　　　　　　　　　　　　　　case Male

　　　　　　　　　　　　　　　　　　　　case Female

　　　　　　　　　　　　　　　　}

　　　　　　　　   第二种方式： enum Week{

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

　　　　　　　　　　　　　　}

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

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

 mport UIKit
 /****下标***********************/
 class Teacher {
     var students = ["a","b","c"]

     subscript(i: Int) ->String  {
         get{
             return students[i]
         }
         set(nv) {
             students[i] = nv
         }

     }

 }

 let t = Teacher()
 t[]
 t[] = "bbbb"
 t[]
 //下标参数可以有多个，每个参数的类型也可以不一样

 /*  可为空的类型  */

 //var t1: Teacher = nil
 //在swift中，所有的类型，默认都不能赋值为nil
 //不管是值类型还是引用类型

 //swift对nil（null）进行了集中统一的管理
 //有点类似于一个包装

 //在类型后面添加一个？就表示这个类型是一个可为nil的类型
 var a: Int?   = nil

 //包装类型不是被包装类型，是一个全新的类型，
 //跟被包装类型可以认为没有任何的关系

 //wrapper
 //class Nullable<T> {
 //    var p: T
 //    var p2 = nil
 //}
 a =
 a = nil
 a
 a =
 a!
 if let b = a  {

 }

 /********** 枚举    *////////////

 enum Gender {
     case Male
     case Female
 }

 enum Week {
     case Monday,Tue,Wed,Thi,Fir,Sat
     case Sun
 }
 let w = Week.Sun
 let g = Gender.Male
 switch g {
 //case Gender.Female:
 //    print("nv...")

 //default:
 //    print("nan")

     case .Female:
         print("nv...")
     case .Male:
         print("nan...")
 }

 //原生值（Raw Value）

 //原生值类型只能是字符类型（CHaracher，string，）和数字类型
 enum FirstEnum: Int {
     case a = ,b,c,d
 }

 let fe = FirstEnum.a
 fe.rawValue

 let f3 = FirstEnum(rawValue: )
 f3
 f3?.rawValue

 //关联值(Associative Value)
 //每个case可以关联多个不同类型的数据
 //也不需要每个case关联的类型是一样的。
 enum TiaoXingMa {
     case YiWei(Int,Int)
     case ErWei(String)
 }

 var txm = TiaoXingMa.YiWei(, )

 txm = .ErWei("asdfasdfasfd")

 //递归枚举（recusive enum）

 indirect enum DiGui {
     case A
     case B(Int)
     case C(DiGui)
 }
 let dga = DiGui.A

 var dg = DiGui.A

 dg = .B()
 //dg = .C(DiGui.A)
 dg = .C(dga)

 //7 * (8+9)
 //7*8 + (9*4)
 indirect enum SuanShuBiaoDaShi {
     case ShuZi(Int)
     case Jia(SuanShuBiaoDaShi,SuanShuBiaoDaShi)
     case Cheng(SuanShuBiaoDaShi,SuanShuBiaoDaShi)
 }
 //7 * (8+9)  // 1+2 * 3+5*8 +4*5
 let exp8 = SuanShuBiaoDaShi.ShuZi()
 let exp7 = SuanShuBiaoDaShi.ShuZi()
 let exp9 = SuanShuBiaoDaShi.ShuZi()

 let exp8jia9 = SuanShuBiaoDaShi.Jia(exp8, exp9)
 let exp7cheng8Jia9 = SuanShuBiaoDaShi.Cheng(exp7, exp8jia9)

 func yunsuan(exp: SuanShuBiaoDaShi) -> Int {

     switch exp {
     case .ShuZi(let num):
         return num
     case let .Jia(left, right):
         return yunsuan(exp: left) + yunsuan(exp: right)
     case  .Cheng(let left, let right):
         return yunsuan(exp: left) * yunsuan(exp: right)

     }

 }

 let result = yunsuan(exp: exp7cheng8Jia9)
 result

 //算出3+2
 //算出5*3
 //算出（1+2）*（3+4）

 //算出自然数的和
 //func add(max: int)->int
 //从1开始，max假设为2 结果就是1+ 2
 //如果max 为10 加过1+2+3.。。。+10
 //1构建一个类。来实现刚才的功能

 //class Person {
 //    var name = "meiyouminzi"
 //    var shangSi: Person?
 //}
 //
 //let ceo = Person()
 //ceo.name = "chenjun"
 //
 //let lieyuanjun = Person()
 //lieyuanjun.name = "lieyuanjun"
 //lieyuanjun.shangSi = ceo

 //class Person {
 //    var name = "meiyoumingzi"
 //    var father: Person?
 //    var mother: Person?
 //}
 //let cj = Person()
 //cj.name = "cj"
 //let cjf = Person()
 //
 //cjf.name = "cjf"
 //let cjm = Person()
 //cjm.name = "cjm"
 //cj.father = cjf
 //cj.mother = cjm

 class Expression {
     var caozuofu = ""
     var shuzi =
     var left: Expression?
     var right: Expression?

     func yunsuan(exp: Expression) -> Int {

         switch exp.caozuofu {
         case "+":
             return yunsuan(exp: exp.left!) + yunsuan(exp:  exp.right!)
         case  "*":
             return yunsuan(exp: exp.left!) * yunsuan(exp: exp.right!)
         default:
             return exp.shuzi
         }

     }

 }

 let e7 = Expression()
 e7.shuzi =
 let e8 = Expression()
 e8.shuzi =
 let e9 = Expression()
 e9.shuzi = 

 let e89 = Expression()
 e89.caozuofu = "+"
 e89.left = e8
 e89.right = e9
 let e7mule89 = Expression()
 e7mule89.caozuofu = "*"
 e7mule89.left = e7
 e7mule89.right = e89

 let rys = e7mule89.yunsuan(exp: e7mule89)
 //let ys = Expression()
 //let cys = ys.yunsuan(exp: (e7mule89))

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

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

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