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

5. 类和结构体的选择

结构体实例老是经过值传递，类实例老是经过引用传递。这意味二者适用不一样的任务。当你的在考虑一个工程项目的数据构造和功能的时候，你须要决定每一个数据构造是定义成类仍是结构体。code

当符合一条或多条如下条件时，请考虑构建结构体：

结构体的主要目的是用来封装少许相关简单数据值。

有理由预计一个结构体实例在赋值或传递时，封装的数据将会被拷贝而不是被引用。

任何在结构体中储存的值类型属性，也将会被拷贝，而不是被引用。

结构体不须要去继承另外一个已存在类型的属性或者行为。

合适的结构体候选者包括：

几何形状的大小

必定范围内的路径

三维坐标系内一点