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[0]
t[1] = "bbbb"
t[1]
//下标参数可以有多个，每个参数的类型也可以不一样

/*  可为空的类型  */

//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 = 5
a = nil
a
a = 6
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 = 15,b,c,d
}

let fe = FirstEnum.a
fe.rawValue

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

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

var txm = TiaoXingMa.YiWei(9, 1234)

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(555)
//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(8)
let exp7 = SuanShuBiaoDaShi.ShuZi(7)
let exp9 = SuanShuBiaoDaShi.ShuZi(9)

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 = 0
    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 = 7
let e8 = Expression()
e8.shuzi = 8
let e9 = Expression()
e9.shuzi = 9

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.