Felix's Notes

列舉為一個新的型別, 所以必需依照camel naming, 每個單字字首均為大寫
enum MyType {
    case A
    case B
    case C
}

//多個定義式可寫在同一行
enum MyType {
    case A, B, C
}

//若以switch來匹配enum, 則enum中所有case都要列舉, 或者要加上default值
var mt = MyType.A

switch mt {
    case .A:
        print("A")
    case .B:
        print("B")    
}
//未宣告csae .C, 在compile時會出現error

//關聯值 : 每個enum item可以自帶不同的資料類型
enum Man {
    case Warrior (Int, String)
    case Magic (Int,Int)
    case Rogue (Int, Bool)
}

var newOne = Man.Magic(100,100)
print(newOne)

newOne = .Rogue(200, true)
print(newOne)

//Case 1
switch newOne {
    case .Warrior (let HP, let Power):
        print("\(HP) - \(Power)")
    case .Magic (let HP, let MP):
        print("\(HP) - \(MP)")
    case .Rogue(let HP, let Hide):
        print("\(HP) - \(Hide)")
}

//Case 2
switch newOne {
    case let .Warrior (HP, Power):
        print("\(HP) - \(Power)")
    case let .Magic (HP, MP):
        print("\(HP) - \(MP)")
    case let .Rogue( HP,  Hide):
        print("\(HP) - \(Hide)")
}

//原始值: 指派值給enum item, 不得重覆, 必需為同型別, 若使用Int做為原始值, 若其他項目沒有特別設定, 則會自動遞增
enum AnimalOrder : Int {
    case Rat=1, Ox, Tiger, Rabbit, Dragon
}

print("\(AnimalOrder.Rabbit.rawValue)")

var one = AnimalOrder(rawValue:3)
print(one!)

//為參考型別
class ClassName {
   ...
}　　

//為值的類型
struct StructName {
    ...
}　　

//延遲屬性: Lazy binding: 當宣告為Lazy時, 直到第一次叫用才會實際產生值

class CountVal {
    init () {
        var i=0
        for _ in 0...9999 {
            i++
        }
    }
}

class Data1 {
    var result = CountVal() 
}

var t1 = Data1() //此時已產生result值

class Data2 {
    lazy var result = CountVal()
}

var t2 = Data2() //此時未產生result值
var t2Result = t2.result //此時才產生result值

//get/set
struct Years {
    var year = 0
    var yearROC : Int {
        get {
            return (year - 1911)
        }
        set (newYearROC) {
            year = newYearROC + 1911
        }
    }
}

//Simplx set
struct Years {
    var year = 0
    var yearROC : Int {
        get {
            return (year - 1911)
        }
        set {
            year = newValue + 1911
        }
    }
}

//Read Only :only has get
struct Years {
    var year = 0
    var yearROC : Int {
        get {
            return (year - 1911)
        }
    }
}

//Simplex Read Only
struct Years {
    var year = 0
    var yearROC : Int {
        return (year - 1911)
    }
}

class NewOne {
    var val = 100 {
        willSet(newVal) {
            print("Original val=\(val), will be set to \(newVal)")
        }
        didSet {
            print("Original val=\(oldValue), will be set to \(val)")
        }
    }
}

struct Man{
    static var leg = 2
    var age = 30
}

let newMan = Man()

print(newMan.age) //一般屬性, 使用實體名稱來叫用
print(Man.leg) //靜態屬性, 使用類別名稱來叫用

- 參數名稱前加底線, 當呼叫此方法時, 可不加外部參數名稱
- self : 指向clas/struct本身
- 在struct中的func, 要修改其他屬性值, 要將此func宣告為變異(mutating)

- 可重載
- 可多重參數
class A {
    var item = [1,2,3]
    subscript(index : Int) -> Int {
        get {
            ....
        }
        set(newValue) {
            ....
        }    
    }


}