自定义数据类型 --- 枚举类型全解（swift2.3）

最新推荐文章于 2024-06-11 22:32:38 发布

尹欢一

最新推荐文章于 2024-06-11 22:32:38 发布

阅读量1.2k

点赞数 1

分类专栏： iOS 日常学习笔记 iOS 记录生活的点点滴滴文章标签： swift

本文链接：https://blog.csdn.net/yhy1271927580/article/details/51789453

版权

iOS 日常学习笔记同时被 2 个专栏收录

28 篇文章 0 订阅

订阅专栏

iOS 记录生活的点点滴滴

21 篇文章 0 订阅

订阅专栏

自定义数据类型 — 枚举（swift）

下面简单的介绍枚举这一自定义数据类型的应用

枚举的基本语法
枚举中rawValue应用
枚举中associatedValue应用
可选型的实质类型就是枚举
枚举的递归应用

一：枚举的基础语法

import UIKit

//: 1.定义一个类型为Month的枚举类型，这个枚举类型有12种可能性
enum Month {
    case January,February,March,April,May, June,July,August, September,October,November,December
}

 //：2.那么枚举这种自定义数据类型，可以像类一样，定义一个变量,这里可以不需要写month的数据类型，因为swift会infer month的数据类型为Month
let curMonth = Month.October

 //: 3.下面我们定义一个函数，将函数参数的类型设置为我们定义的枚举类型，函数的返回值为String类型
func season( month: Month) ->String{

    switch month { //在这里要注意的是：switch选择的永远都是参数的变量名，不是数据类型

    case .January: //case 是判断这个枚举变量是哪一种可能性

        return "1"

    case .February: //由于switch判断的是month这个枚举类型的可能性，month一共有12种可能性，我这里将其一一的列举出来了，那么就不需要default了
        return "2"

    case .March :

        return "3"

    case .April :

        return "4"

    case .May :

        return "5"

    case .June :

        return "6"

    case .July :

        return "7"

    case .August :

        return "8"

    case .September :

        return "9"

    case .October :

        return "10"

    case .November :

        return "11"

    case .December :

        return "12"
    }


}

//调用刚刚定义的函数，由于这个函数可以传入一个参数，那么将Month.October的变量名curMonth传入进去，来通过函数中的switch来判断这个枚举变量是哪一种情况
season(curMonth)

二：枚举中rawValue应用

1.通过枚举类型的可能性获取肯能性的int值

//由于枚举类型的每一种可能性都与一个int类型的整数相互关联，那么在函数中，通过参数的点语法的rawValue可以拿到这个枚举变量的rawValue值
 // 定义raw value，完全定义
enum Month: Int{//这样就手动的将Month中的各种可能性和int结合起来了
    case January = 1
    case February = 2
    case March = 3
    case April = 4
    case May = 5
    case June = 6
    case July = 7
    case August = 8
    case September = 9
    case October = 10
    case November = 11
    case December = 12
}

//定义一个函数，计算传入一个Month变量的参数后，计算出还剩下多少月
func howManyMonthesleft( cruMonth: Month) -> Int{

    return 12 - cruMonth.rawValue

}

//定义一个枚举变量
let curMonth = Month.July

//将curMonth作为函数的参数调调用,这个简单的例子说明了枚举类型的可能性可以与int一一对应
howManyMonthesleft(curMonth)

2.通过枚举类型的rawValue获取肯能性值

//由于枚举类型的每一种可能性都与一个int类型的整数相互关联，那么在函数中，通过参数的点语法的rawValue可以拿到这个枚举变量的rawValue值
 // 定义raw value，完全定义
enum Month: Int{//这样就手动的将Month中的各种可能性和int结合起来了
    case January = 1
    case February = 2
    case March = 3
    case April = 4
    case May = 5
    case June = 6
    case July = 7
    case August = 8
    case September = 9
    case October = 10
    case November = 11
    case December = 12
}

//定义一个函数，计算传入一个Month变量的参数后，计算出还剩下多少月
func howManyMonthesleft( cruMonth: Month) -> Int{

    return 12 - cruMonth.rawValue

}

let input = 11



//通过枚举类型的构造函数定义枚举变量,此时定义的变量是一个可选型变量
let curMonth = Month(rawValue: input)

//将curMonth作为函数的参数调调用,这个简单的例子说明了枚举类型的可能性可以与int一一对应
if let curMonth = curMonth{//将可选型curMonth进行解包，得到的是一个Month类型的变量
howManyMonthesleft(curMonth)
}

3.在枚举类型的定义中，也可以没给可能性绑定int值，这样系统会自动将各种可能性按0开始编码

enum Month: Int{//这样就手动的将Month中的各种可能性和int结合起来了
    case January
    case February
    case March
    case April
    case May
    case June
    case July
    case August
    case September
    case October
    case November
    case December
}

//定义一个函数，计算传入一个Month变量的参数后，计算出还剩下多少月
func howManyMonthesleft( cruMonth: Month) -> Int{

    return 12 - cruMonth.rawValue

}

let input = 11



//通过枚举类型的构造函数定义枚举变量,此时定义的变量是一个可选型变量
let curMonth = Month(rawValue: input)

//将curMonth作为函数的参数调调用,这个简单的例子说明了枚举类型的可能性可以与int一一对应
if let curMonth = curMonth{//将可选型curMonth进行解包，得到的是一个Month类型的变量
howManyMonthesleft(curMonth)//这样计算出来的值也是对的
}

4.枚举类型的可能性绑定的类型也可以是String类型，不一定都是int类型

// 使用String作为raw value有默认值
enum ProgrammingLanguage2: String{
    case Swift = "swift"
    case ObjectiveC = "Objective-C"
    case C = "c"
    case Java = "java"
}

let myFavoriteLanguage2: ProgrammingLanguage2 = .Swift
print( "\(myFavoriteLanguage2.rawValue) is my favorite language.")

三：枚举中associatedValue应用
1.枚举类型中单个关联值（基本类型关联值）

// Associate Value 和 Raw value 只能存在一个
enum ATMStatus{//如果是设置枚举变量的Associate Value，就不能设置枚举变量的Raw Value.这里将枚举类型的各种可以性关联不同的数据类型
    case Success(Int)
    case Erro(String)
    case Wainting //也可以不关联任何职

}

//下面我们第一个函数,函数的参数类型为int，放回值为ATMStatus枚举类型

var balance = 1000

func withDraw(amount: Int) -> ATMStatus {

    if balance >= amount{

        balance -= amount

        return .Success(balance)

    }else{

        return .Erro("your account is not enough")
    }

}

//解包的方式有两种：一种是刘老师说的，一种是Stanford大学白胡子老头说的
let result = withDraw(1009)//但是现在返回给我们的还是一个枚举类型的肯能性，那么需要将可能性里面的关联值解包出来

switch result{

case let .Success(newBalance):
    print(newBalance)
case let .Erro(newString):
    print(newString)
case .Wainting:
    print("please wait a minute")
}

//方法二：Stanford大学白胡子老头（随便提一句，解析关联值不是必须的）
let result1 = withDraw(100)

switch result1{

case .Success(let newBalance):

    print(newBalance)

case .Erro(let newString):

    print(newString)

case .Wainting:

    break

}

2.多个关联值（可以是tuple类型，也可以是函数类型 —>在Stanford大学有提到）


func multiply(op1: Double, op2: Double) -> Double {


    return op1 * op2



}

// Associate Value 和 Raw value 只能存在一个
enum ATMStatus{//如果是设置枚举变量的Associate Value，就不能设置枚举变量的Raw Value.这里将枚举类型的各种可以性关联不同的数据类型
    case Success(Int)
    case Erro(String)
    case Wainting //也可以不关联任何职

}

//下面我们第一个函数,函数的参数类型为int，放回值为ATMStatus枚举类型

var balance = 1000

func withDraw(amount: Int) -> ATMStatus {

    if balance >= amount{

        balance -= amount

        return .Success(balance)

    }else{

        return .Erro("your account is not enough")
    }

}

//解包的方式有两种：一种是刘老师说的，一种是Stanford大学白胡子老头说的
let result = withDraw(1009)//但是现在返回给我们的还是一个枚举类型的肯能性，那么需要将可能性里面的关联值解包出来

switch result{

case let .Success(newBalance):
    print(newBalance)
case let .Erro(newString):
    print(newString)
case .Wainting:
    print("please wait a minute")
}

//方法二：Stanford大学白胡子老头（随便提一句，解析关联值不是必须的）
let result1 = withDraw(100)

switch result1{

case .Success(let newBalance):

    print(newBalance)

case .Erro(let newString):

    print(newString)

case .Wainting:

    break

}



//定义一个有多个关联值的枚举类型
enum Shape {
    case square( Double)

    case rectangle( Double, Double)

    case circle( Double,  Double, Double)

    case simpleOperation(Double ->Double)//sqrt:求一个数的平方根(stanford University)

    case point

    case multiple((Double,Double) ->Double)
}

//定义这个枚举类型的变量

let rectangle = Shape.rectangle(10, 10) //定义枚举变量的目的是作为函数的参数

let foo = Shape.simpleOperation(sqrt)

let square = Shape.square(20)

let circle = Shape.circle(0, 0, 30)

let point = Shape.point

var result2 = 9.0

var result3 = 10.0

let fooo = Shape.multiple(multiply)


//定义一个函数来计算每一个图形的面积

func culculateShape(shape: Shape) -> Double {

    switch shape {
    case .rectangle(let width,let height)://stanford University

        return width * height

    case let .circle(_, _, radius)://imooc University

        return M_PI * radius * radius

    case .square(let side):

        return side * side

    case .simpleOperation(let food):

        return  food(result2)

    case .point:

        return 0

    case .multiple(let fooo):

        return fooo(result2,result3)

    }


}

var area = culculateShape(rectangle)

var area1 = culculateShape(square)

var area2 = culculateShape(circle)

var area3 = culculateShape(point)

var resultNumble = culculateShape(foo)//这里将sqrt函数作为关联值

var re = culculateShape(fooo)

四：可选型的实质类型就是枚举

var age: Int? = 12

print(age)

age = nil

print(age)

//其实swift内部就是封装了一个类型名为optional的枚举型，那么person就是一个枚举型变量
var person = Optional.Some("尹欢一")

person = .None

//那么在赋值的时候，可以直接赋值

person = "你好，尹欢一"

person = nil

//那么可选型的解包方法就有两种

//使用switch解包
switch person{

case .Some(let name):

    print(name)

case .None:

    print("没有解包")

}

//2.赋值解包

if let person = person{

    print(person)

}else{

print("nil")

}

五：枚举的递归应用


// 枚举递归，使用indirect关键字
enum ArithmeticExpression{

    case Number(Int)
    indirect case Addition( ArithmeticExpression , ArithmeticExpression )
    indirect case Multiplication( ArithmeticExpression , ArithmeticExpression )
}

// 也可以直接将indirect关键字放在整个enum前面
indirect enum ArithmeticExpression2{

    case Number(Int)
    case Addition( ArithmeticExpression , ArithmeticExpression )
    case Multiplication( ArithmeticExpression , ArithmeticExpression )
}


// (5 + 4) * 2
let five = ArithmeticExpression.Number(5)
let four = ArithmeticExpression.Number(4)
let sum = ArithmeticExpression.Addition(five, four)
let two = ArithmeticExpression.Number(2)
let product = ArithmeticExpression.Multiplication(sum, two)


func evaluate(expression: ArithmeticExpression) -> Int {
    switch expression {
    case  .Number(let value):
        return value
    case  .Addition(let left, let right):
        return evaluate(left) + evaluate(right)//由于不知道第一次解包出来的是不是一个数，所以在这里将解包出来的表达是再调用这个函数，再进行解析，这样就实现了递归操作
    case  .Multiplication(let left, let right):
        return evaluate(left) * evaluate(right)
    }
}


evaluate(product)