iOS学习笔记44-Swift(四)枚举和结构体

一、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 = "div"
}
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. 类和结构体的选择

结构体实例总是通过值传递，类实例总是通过引用传递。这意味两者适用不同的任务。当你的在考虑一个工程项目的数据构造和功能的时候，你需要决定每个数据构造是定义成类还是结构体。

当符合一条或多条以下条件时，请考虑构建结构体：
  • 结构体的主要目的是用来封装少量相关简单数据值。
  • 有理由预计一个结构体实例在赋值或传递时，封装的数据将会被拷贝而不是被引用。
  • 任何在结构体中储存的值类型属性，也将会被拷贝，而不是被引用。
  • 结构体不需要去继承另一个已存在类型的属性或者行为。
合适的结构体候选者包括：
  • 几何形状的大小
  • 一定范围内的路径
  • 三维坐标系内一点

时间： 2024-10-11 05:49:27

iOS学习笔记44-Swift(四)枚举和结构体的相关文章

Swift学习——A Swift Tour 枚举和结构体

Enumerations and Structures Enumerations   枚举的使用 使用 enum 定义一个枚举,枚举里面可以关联方法,比如下文中的描述方法 enum Rank: Int { case Ace = 1 case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten case Jack, Queen, King func simpleDescription() -> String { switch self { ca

黑马程序员学习笔记--------C语言变量类型，结构体，枚举

本章学习的知识是定义结构体,枚举等自定义的数据类型,已经宏命令,变量类型等细小的知识点,在开始本章的新知识学习之前首先我们要明白的是C语言有丰富的数据类型和运算符,因此计算能力非常强大,计算过程中使用的值一般用变量来存储.变量也是有分类型的,不同类型的变量有不同的存储类型.不同的生命周期.不同的作用域,C语言也提供了一些关键字来设置变量的属性(比如设置存储类型.生命周期). 一.变量类型 变量分为全局变量和局部变量. 首先说明一下局部变量的特点 1> 定义:在函数内部定义的变量,称为局部变量.形

【学习笔记】【C语言】结构体

1.定义结构体变量的3种方式 1> 先定义类型,再定义变量(分开定义) struct Student {    int age; }; struct Student stu;  2> 定义类型的同时定义变量 struct Student {    int age; } stu; struct Student stu2;  3> 定义类型的同时定义变量(省略了类型名称) struct {    int age; } stu;  2.结构体类型的作用域 1> 定义在函数外面:全局有效(

swift 定义枚举和结构体 及使用

//定义枚举 enum MapDirection { case North case South case East case West func simpleDescription() -> String { switch self { case .North: return "North" case .South: return "South" case .East: return "East" case .West: return &

iOS学习笔记（十四）——打电话、发短信

电话.短信是手机的基础功能,iOS中提供了接口,让我们调用.这篇文章简单的介绍一下iOS的打电话.发短信在程序中怎么调用. 1.打电话 [[UIApplication sharedApplication] openURL:[NSURL URLWithString:@"tel://10010"]];//打电话 使用openURL这个API打电话结束后,返回的是系统的拨打电话界面,如何才能返回自己的应用呢?有两种方法与大家分享. 第一种是用UIWebView加载电话,这种是合法的,可以上A

【IOS学习笔记】Swift iOS 日期操作：NSDate、NSDateFormatter（转载）

转载自:http://blog.csdn.net/jinnchang/article/details/44592801 1.日期(NSDate) [objc] view plaincopy // 1.初始化 // 初始化一个当前时刻对象 var now = NSDate() // 初始化一个明天当前时刻对象 var tomorrow = NSDate(timeIntervalSinceNow: 24*60*60) // 初始化一个昨天当前时刻对象 var yestoday = NSDate(ti

【学习笔记】【C语言】结构体和函数

1 #include <stdio.h> 2 struct Student 3 { 4 int age; 5 int no; 6 }; 7 8 // 如果结构体作为函数参数,只是将实参结构体所有成员的值对应地赋值给了形参结构体的所有成员 9 // 修改函数内部结构体的成员不会影响外面的实参结构体 10 void test(struct Student s) 11 { 12 s.age = 30; 13 s.no = 2; 14 } 15 16 // 会影响外面的实参结构体 17 void te

【学习笔记】【C语言】结构体的嵌套

1 #include <stdio.h> 2 3 int main() 4 { 5 struct Date 6 { 7 int year; 8 int month; 9 int day; 10 }; 11 12 13 // 类型 14 struct Student 15 { 16 int no; // 学号 17 18 struct Date birthday; // 生日 19 20 struct Date ruxueDate; // 入学日期 21 22 // 这种写法是错误的 23 //

iOS: 学习笔记, Swift操作符定义

Swift操作符可以自行定义, 只需要加上简单的标志符即可. @infix 中置运算. 如+,-,*,/运算 @prefix 前置运算. 如- @postfix 后置运算. a++, a-- @assignment 赋值运算. +=, -=, --a, ++a // // main.swift // SwiftBasic // // Created by yao_yu on 14-7-27. // Copyright (c) 2014年 yao_yu. All rights reserved.