swift 的枚舉、結構體、類

時間 2019-12-05

標籤 swift 枚舉結構欄目 Swift 简体版

原文原文鏈接

1、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語句結合進行值匹配

 1 method = Method.Sub
 2 // 注意: 若是case中包含了全部的值, 能夠不寫default
 3 // 若是case中沒有包含枚舉中全部的值, 必須寫default
 4 switch(method){
 5     case Method.Add:
 6         print("加法")
 7     case .Sub:// 若是變量已經指定了枚舉類型，能夠把前面的枚舉類型省略
 8         print("減法")
 9     case .Mul:
10         print("除法")
11     case .Div:
12         print("乘法")
13     default:
14         print("都不是")
15 }

3. 枚舉的原始值

OC中枚舉的本質就是整數，因此OC中的枚舉是有原始值的，默認是從0開始，而Swift中的枚舉默認是沒有原始值的，可是能夠在定義時告訴系統讓枚舉有原始值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 = "div"
}
enum Constants: Double {
    case π = 3.14159
    case e = 2.71828
    case φ = 1.61803398874
    case λ = 1.30357
}

枚舉值和原始值之間的轉化：

 1 // 獲取枚舉值對應的原始值
 2 println("Method.Add原始值爲：\(Method.Add.rawValue)")
 3 //打印：Method.Add原始值爲：add
 4 
 5 /*
 6 經過原始值建立枚舉值
 7 注意: 
 8 1.原始值區分大小寫
 9 2.返回的是一個可選類型值，由於原始值對應的枚舉值不必定存在
10 */
11 let method = Method(rawValue: "add")
12 // 因爲返回是可選類型, 因此有可能爲nil, 最好使用可選綁定
13 if let opE = Method(rawValue: "sub"){
14     switch (opE){
15         case .Add:
16             print("加法")
17         case .Sub:
18             print("減法")
19         case .Mul:
20             print("除法")
21         case .Div:
22             print("乘法")
23     }
24 }

4. 枚舉的關聯值

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

枚舉的關聯值使用

 1 //定義一個交易枚舉
 2 enum TradeTmp {
 3     case Buy(String, Int) //買，關聯一個字符串和一個整形
 4     case Sell(String, Int) //賣，關聯一個字符串和一個整形
 5     case Borrow(String, Int, String) //借，每一個枚舉值的關聯類型能夠不同
 6 }
 7 //從新定義一個交易枚舉，爲關聯值加上標籤說明
 8 enum Trade {
 9     case Buy(stock: String, amount: Int) //買，關聯股票名和交易數量
10     case Sell(stock: String, amount: Int) //賣，關聯股票名和交易數量
11 }
12 //建立一個枚舉，關聯某些值
13 var tradeBuy = Trade.Buy(stock: "百度", amount: 2000)
14 var tradeBuy2 = Trade.Buy(stock: "APPL", amount: 4000)
15 var tradeSell = Trade.Sell(stock: "APPL", amount: 1000)
16 //第一種方式提取關聯值，利用switch語句提取關聯值
17 switch(tradeBuy){
18     case .Buy(let stock, let amount):
19         print("Buy \(stock) with \(amount) number")
20     case let .Sell(stock, amount)://簡化
21         print("Sell \(stock) with \(amount) number")
22 }
23 //第二種方式提取關聯值，使用模式匹配提取關聯值
24 if case let Trade.Sell(stock, amount) = tradeSell {
25     print("Sell \(amount) of \(stock)")
26 }

5. 枚舉的屬性

儘管增長一個存儲屬性到枚舉中不被容許，但你依然可以建立計算屬性。固然，計算屬性的內容都是創建在枚舉值下或者枚舉關聯值獲得的。安全

 1 //定義枚舉，添加一個計算屬性
 2 enum Device {
 3     case iPad, iPhone
 4     var year: Int {
 5         switch self {
 6             case iPhone: return 2007
 7             case iPad: return 2010
 8         }
 9     }
10 }
11 //建立一個枚舉值
12 var device = Device.iPad
13 print("iPad is \(device.year)") //結果：iPad is 2010

6. 枚舉的方法

枚舉中的方法爲每個枚舉值而「生」。因此假若想要在特定狀況執行特定代碼的話，你須要分支處理或採用switch語句來明確正確的代碼路徑。編程語言

 1 enum Wearable {
 2     //枚舉中能夠嵌套枚舉
 3     enum Weight: Int {
 4         case Light = 1
 5     }
 6     enum Armor: Int {
 7         case Light = 2
 8     }
 9     //枚舉值，指定了weight和armor的類型
10     case Helmet(weight: Weight, armor: Armor)
11     //枚舉方法
12     func attributes() -> (weight: Int, armor: Int) {
13         switch self {
14             case .Helmet(let w, let a):
15                 return (w.rawValue * 2, a.rawValue * 4)
16         }
17     }
18 }
19 //由於weight和armor都已經指定了枚舉類型，直接使用點枚舉值
20 let wearable = Wearable.Helmet(weight: .Light, armor: .Light)
21 let woodenHelmetProps = wearable.attributes()
22 print(woodenHelmetProps) //結果：(2, 8)

也能夠在枚舉中添加靜態方法，換言之經過一個非枚舉類型來建立一個枚舉。
在這個示例中,咱們須要考慮用戶有時將蘋果設備叫錯的狀況(好比AppleWatch叫成iWatch)，須要返回一個合適的名稱。ide

 1 enum Device {
 2     case AppleWatch
 3     //添加靜態方法
 4     static func fromSlang(term: String) -> Device? {
 5         if term == "iWatch" {
 6             return .AppleWatch
 7         }
 8         return nil
 9     }
10 }
11 var device = Device.fromSlang("iWatch") //device爲 Device? 類型

2、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) print(marks.mark1) print(marks.mark2) print(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 print("x=\(myPoint.point.x),y=\(myPoint.point.y)") //運行結果：x=10.0,y=11.0

3. 結構體的方法

 1 //結構體內部只有在構造函數（init）中能夠修改屬性的值，其餘方法內不能直接修改結構體內部屬性的值。
 2 struct Rect {
 3     var width:Double
 4     var height:Double = 0.0
 5     // 給結構體定義一個方法, 該方法屬於該結構體
 6     // 結構體中的成員方法必須使用某個實例調用
 7     // 成員方法能夠訪問成員屬性
 8     func getWidth() -> Double{
 9         return width
10     }
11 }
12 var rect = Rect(width: 10.0, height: 20.0)
13 // 結構體中的成員方法是和某個實例對象綁定在一塊兒的, 因此誰調用, 方法中訪問的屬性就屬於誰
14 print(rect.getWidth())
15 
16 var rect2 = Rect(width: 30.0, height: 20.0)
17 // 取得rect2這個對象的寬度
18 print(rect2.getWidth())

4. 值類型和引用類型

值類型被賦予給一個變量、常數或者自己被傳遞給一個函數的時候，實際上操做的是值的拷貝。
實際上，在Swift中，全部的基本類型：整數、浮點數、布爾值、字符串、數組和字典，都是值類型，而且都是以結構體的形式在後臺所實現。
在Swift中，全部的結構體和枚舉都是值類型。這意味着它們的實例，以及實例中所包含的任何值類型屬性，在代碼中傳遞的時候都會被複制。ui

值類型賦值

 1 struct Resolution {
 2     var width = 0
 3     var height = 0
 4 }
 5 //建立一個結構體
 6 let hd = Resolution(width: 1920, height: 1080)
 7 //結構體賦值，實際上作的是拷貝操做，cinema和hd結構體在內存中各自佔用獨立的空間
 8 var cinema = hd
 9 //修改cinema結構體，不會影響hd結構體
10 cinema.width = 2048
11 print("cinema is now  \(cinema.width) pixels wide")
12 //結果：cinema is now 2048 pixels wide
13 print("hd is still \(hd.width ) pixels wide")
14 //結果：hd is still 1920 pixels wide

與值類型不一樣，引用類型在被賦予到一個變量、常量或者被傳遞到一個函數時，操做的並非其拷貝。所以，引用的是已存在的實例自己而不是其拷貝。
類就是引用類型。spa

引用類型賦值

 1 class ResolutionClass {
 2     var width = 0
 3     var height = 0
 4     init(width: Int, height: Int) {
 5         self.width = width
 6         self.height = height
 7     }
 8 }
 9 //建立一個類對象
10 let hdClass = ResolutionClass(width: 1920, height: 1080)
11 //類對象賦值，引用同一個內存空間
12 var cinemaClass = hdClass 
13 //修改cinema對象，本質上也是修改hdClass對象
14 cinemaClass.width = 2048
15 print("cinemaClass is now  \(cinemaClass .width) pixels wide")
16 //結果：cinema is now 2048 pixels wide
17 print("hdClass is also \(hdClass.width ) pixels wide")
18 //結果：hd is also 2048 pixels wide