初学swift_004

下标操作，枚举和类的递归

//: Playground - noun: a place where people can play
import 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
/***类的递归****/
//构建一个类。来实现刚才的功能

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))
​