iOS學習筆記44-Swift(四)枚舉和結構體 – iPhone手機開發 iPhone軟體開發教學課程

一、Swift的枚舉

枚舉是一系相關聯的值定義的一個公共的組類型,同時能夠讓你在編程的時候在類型安全的情況下去使用這些值。
Swift中的枚舉比OC中的枚舉強大得多,因為Swift中的枚舉是一等類型,它除瞭可以定義枚舉值外,還可以在枚舉中像類一樣定義屬性和方法

1. 簡單枚舉定義和使用
//定義枚舉,使用enum關鍵字
enum Method{
    case Add
    case Sub
    case Mul
    case Div
}
//可以連在一起寫,成員之間用“,“隔開
enum CompassPoint {
    case North, South, East, West
}
// 可以使用枚舉類型變量或常量接收枚舉值,枚舉值前有個點
var method: Method = .Add
// 註意: 如果變量或常量沒有指定類型, 那麼前面必須加上該值屬於哪個枚舉類型
var point = CompassPoint.North
2. 枚舉和switch語句結合進行值匹配
method = Method.Sub
// 註意: 如果case中包含瞭所有的值, 可以不寫default
// 如果case中沒有包含枚舉中所有的值, 必須寫default
switch(method){
    case Method.Add:
        print("加法")
    case .Sub:// 如果變量已經指定瞭枚舉類型,可以把前面的枚舉類型省略
        print("減法")
    case .Mul:
        print("除法")
    case .Div:
        print("乘法")
    default:
        print("都不是")
}
3. 枚舉的原始值

OC中枚舉的本質就是整數,所以OC中的枚舉是有原始值的,默認是從0開始,而Swift中的枚舉默認是沒有原始值的,但是可以在定義時告訴系統讓枚舉有原始值

枚舉定義原始值:
//定義枚舉類型為Int類型,默認從0開始,後面逐一加一
enum CompassPoint: Int {
    case North, South, East, West
}
//定義枚舉類型為Int類型,從指定值開始,後面逐一加一
enum Movement: Int {
    case Left = 5, Right, Top, Bottom
}
//除瞭Int類型,Swift枚舉更加強大,還可以定義為Double、String等
//但是如果指定除Int的其他類型,需要給所有枚舉值賦值
enum Method: String {
    case Add = "add"
    case Sub = "sub"
    case Mul = "mul"
    case Div = "p"
}
enum Constants: Double {
    case π = 3.14159
    case e = 2.71828
    case φ = 1.61803398874
    case λ = 1.30357
}
枚舉值和原始值之間的轉化:

// 獲取枚舉值對應的原始值
println("Method.Add原始值為:\(Method.Add.rawValue)")
//打印:Method.Add原始值為:add

/*
通過原始值創建枚舉值
註意: 
1.原始值區分大小寫
2.返回的是一個可選類型值,因為原始值對應的枚舉值不一定存在
*/
let method = Method(rawValue: "add")
// 由於返回是可選類型,所以有可能為nil,最好使用可選綁定
if let opE = Method(rawValue: "sub"){
    switch (opE){
        case .Add:
            print("加法")
        case .Sub:
            print("減法")
        case .Mul:
            print("除法")
        case .Div:
            print("乘法")
    }
}
4. 枚舉的關聯值

枚舉的關聯值是將額外信息附加到枚舉值中的一種極好的方式。使用關聯值,每一個枚舉值就可以是在某種模式下的一些特定值。
打個比方,你正在開發一款交易引擎,可能存在“買”和“賣”兩種不同的交易類型。除此之外每手交易還要制定明確的股票名稱和交易數量

枚舉的關聯值使用
//定義一個交易枚舉
enum TradeTmp {
    case Buy(String, Int) //買,關聯一個字符串和一個整形
    case Sell(String, Int) //賣,關聯一個字符串和一個整形
    case Borrow(String, Int, String) //借,每個枚舉值的關聯類型可以不一樣
}
//重新定義一個交易枚舉,為關聯值加上標簽說明
enum Trade {
    case Buy(stock: String, amount: Int) //買,關聯股票名和交易數量
    case Sell(stock: String, amount: Int) //賣,關聯股票名和交易數量
}
//創建一個枚舉,關聯某些值
var tradeBuy = Trade.Buy(stock: "百度", amount: 2000)
var tradeBuy2 = Trade.Buy(stock: "APPL", amount: 4000)
var tradeSell = Trade.Sell(stock: "APPL", amount: 1000)
//第一種方式提取關聯值,利用switch語句提取關聯值
switch(tradeBuy){
    case .Buy(let stock, let amount):
        println("Buy \(stock) with \(amount) number")
    case let .Sell(stock, amount)://簡化
        println("Sell \(stock) with \(amount) number")
}
//第二種方式提取關聯值,使用模式匹配提取關聯值
if case let Trade.Sell(stock, amount) = tradeSell {
    println("Sell \(amount) of \(stock)")
}
5. 枚舉的屬性

盡管增加一個存儲屬性到枚舉中不被允許,但你依然能夠創建計算屬性。當然,計算屬性的內容都是建立在枚舉值下或者枚舉關聯值得到的。

//定義枚舉,添加一個計算屬性
enum Device {
    case iPad, iPhone
    var year: Int {
        switch self {
            case iPhone: return 2007
            case iPad: return 2010
        }
    }
}
//創建一個枚舉值
var device = Device.iPad
println("iPad is \(device.year)") //結果:iPad is 2010
6. 枚舉的方法

枚舉中的方法為每一個枚舉值而“生”。所以倘若想要在特定情況執行特定代碼的話,你需要分支處理或采用switch語句來明確正確的代碼路徑。

enum Wearable {
    //枚舉中可以嵌套枚舉
    enum Weight: Int {
        case Light = 1
    }
    enum Armor: Int {
        case Light = 2
    }
    //枚舉值,指定瞭weight和armor的類型
    case Helmet(weight: Weight, armor: Armor)
    //枚舉方法
    func attributes() -> (weight: Int, armor: Int) {
        switch self {
            case .Helmet(let w, let a):
                return (w.rawValue * 2, a.rawValue * 4)
        }
    }
}
//因為weight和armor都已經指定瞭枚舉類型,直接使用點枚舉值
let wearable = Wearable.Helmet(weight: .Light, armor: .Light)
let woodenHelmetProps = wearable.attributes()
println(woodenHelmetProps) //結果:(2, 8)

也可以在枚舉中添加靜態方法,換言之通過一個非枚舉類型來創建一個枚舉。
在這個示例中,我們需要考慮用戶有時將蘋果設備叫錯的情況(比如AppleWatch叫成iWatch),需要返回一個合適的名稱。

enum Device {
    case AppleWatch
    //添加靜態方法
    static func fromSlang(term: String) -> Device? {
        if term == "iWatch" {
            return .AppleWatch
        }
        return nil
    }
}
var device = Device.fromSlang("iWatch") //device為 Device? 類型

二、Swift的結構體

在面向過程的編程語言(如C語言)中,結構體用得比較多,但是面向對象之後,如在C++OC中,結構體已經很少使用瞭。這是因為結構體能夠做的事情,類完全可以取而代之。
Swift語言卻非常重視結構體,把結構體作為實現面向對象的重要手段。Swift中的結構體與C++OC中的結構體有很大的差別,C++OC中的結構體隻能定義一組相關的成員變量,而Swift中的結構體不僅可以定義屬性,還可以定義方法。因此,我們可以把Swfit結構體看做是一種輕量級的類。

Swift中類和結構體的共同處在於:

定義屬性用於存儲值 定義方法用於提供功能 定義下標腳本用於訪問值 定義構造器用於生成初始化值 通過擴展以增加默認實現的功能 實現協議以提供某種標準功能

Swift中類和結構體的不同處在於:

結構體不具有繼承性 結構體不具備運行時強制類型轉換 結構體不具備使用析構器的能力 結構體不具備使用引用計的能力

1. 結構體定義
//結構體定義使用struct關鍵字
struct MarkStruct {
    //結構體也有存儲屬性和計算屬性,這裡隻定義瞭存儲屬性
    var mark1: Int 
    var mark2: Int
    var mark3: Int
}
//所有結構體都有一個自動生成的成員逐一初始化構造器,用於初始化結構體實例中成員的屬性。
//順序必須和結構體成員順序一致,必須包含所有的成員
var marks = MarkStruct(mark1: 98, mark2: 96, mark3:100)
println(marks.mark1)
println(marks.mark2)
println(marks.mark3)
2. 結構體定義屬性
struct Point{
    var x = 0.0
    var y = 0.0
}
struct MyPoint {
    //定義存儲屬性
    var p = Point() 
    //定義計算屬性
    var point:Point{
        get{
            return p
        }
        set(newPoint){//修改newValue名為newPoint,本質還是newValue
            p.x = newPoint.x
            p.y = newPoint.y
        }
    }
}
var p = Point(x:10.0, y:11.0)
var myPoint = MyPoint()
myPoint.point = p
println("x=\(myPoint.point.x),y=\(myPoint.point.y)")
//運行結果:x=10.0,y=11.0
3. 結構體的方法
//結構體內部隻有在構造函數(init)中可以修改屬性的值,其他方法內不能直接修改結構體內部屬性的值。
struct Rect {
    var width:Double
    var height:Double = 0.0
    // 給結構體定義一個方法, 該方法屬於該結構體
    // 結構體中的成員方法必須使用某個實例調用
    // 成員方法可以訪問成員屬性
    func getWidth() -> Double{
        return width
    }
}
var rect = Rect(width: 10.0, height: 20.0)
// 結構體中的成員方法是和某個實例對象綁定在一起的, 所以誰調用, 方法中訪問的屬性就屬於誰
print(rect.getWidth())

var rect2 = Rect(width: 30.0, height: 20.0)
// 取得rect2這個對象的寬度
print(rect2.getWidth())
4. 值類型和引用類型

值類型被賦予給一個變量、常數或者本身被傳遞給一個函數的時候,實際上操作的是值的拷貝。
實際上,在Swift中,所有的基本類型:整數、浮點數、佈爾值、字符串、數組和字典,都是值類型,並且都是以結構體的形式在後臺所實現。
Swift中,所有的結構體和枚舉都是值類型。這意味著它們的實例,以及實例中所包含的任何值類型屬性,在代碼中傳遞的時候都會被復制。

值類型賦值
struct Resolution {
    var width = 0
    var height = 0
}
//創建一個結構體
let hd = Resolution(width: 1920, height: 1080)
//結構體賦值,實際上做的是拷貝操作,cinema和hd結構體在內存中各自占用獨立的空間
var cinema = hd
//修改cinema結構體,不會影響hd結構體
cinema.width = 2048
println("cinema is now  \(cinema.width) pixels wide")
//結果:cinema is now 2048 pixels wide
println("hd is still \(hd.width ) pixels wide")
//結果:hd is still 1920 pixels wide

與值類型不同,引用類型在被賦予到一個變量、常量或者被傳遞到一個函數時,操作的並不是其拷貝。因此,引用的是已存在的實例本身而不是其拷貝。
類就是引用類型

引用類型賦值
class ResolutionClass {
    var width = 0
    var height = 0
    init(width: Int, height: Int) {
        self.width = width
        self.height = height
    }
}
//創建一個類對象
let hdClass = ResolutionClass(width: 1920, height: 1080)
//類對象賦值,引用同一個內存空間
var cinemaClass = hdClass 
//修改cinema對象,本質上也是修改hdClass對象
cinemaClass.width = 2048
println("cinemaClass is now  \(cinemaClass .width) pixels wide")
//結果:cinema is now 2048 pixels wide
println("hdClass is also \(hdClass.width ) pixels wide")
//結果:hd is also 2048 pixels wide
5. 類和結構體的選擇

結構體實例總是通過值傳遞,類實例總是通過引用傳遞。這意味兩者適用不同的任務。當你的在考慮一個工程項目的數據構造和功能的時候,你需要決定每個數據構造是定義成類還是結構體。

當符合一條或多條以下條件時,請考慮構建結構體:

結構體的主要目的是用來封裝少量相關簡單數據值。 有理由預計一個結構體實例在賦值或傳遞時,封裝的數據將會被拷貝而不是被引用。 任何在結構體中儲存的值類型屬性,也將會被拷貝,而不是被引用。 結構體不需要去繼承另一個已存在類型的屬性或者行為。

合適的結構體候選者包括:

幾何形狀的大小 一定范圍內的路徑 三維坐標系內一點

有什麼問題請在下方評論區中提出!O(∩_∩)O哈!

You May Also Like