Swift4.0复习枚举

1.枚举类型：

“Swift编程语言中，枚举类型属于值类型，而不是引用类型。”

摘录来自: “大话Swift 4.0”。 iBooks.

2.枚举类型和枚举对象的定义：

enum Enumeration {
    case value1
    case value2
    case value3; case value4, value5
    case value6
}

3.指定基本类型和原生值：

/// 将IntEnum指定为Int类型
enum IntEnum: Int {
    case zero
    case one = 1, two, three
    case six = 6, seven, eight
}
 
print("one = (IntEnum.one.rawValue)")

var one = IntEnum(rawValue: 0)
if let o = one {
printf("one is: (o)")
printf("one value is: (o.rawValue)")
}

4.枚举关联值：

/// 这里定义了一个枚举MyTestEnum，
/// 它枚举case中含有关联值
enum MyTestEnum {
    /// 这里的value1具有一个Void类型的关联值
    case value1(Void)
     
    /// 这里的value2具有一个Int类型的关联值
    case value2(Int)
     
    /// 这里的value3具有Float、Int、Void与String
    /// 这四个类型的关联值
    case value3(Float, Int, Void, String)
 }

/// 这里用的关联值为10
let e2 = MyTestEnum.value2(10)

5.递归枚举：

“如果一个枚举类型中某一枚举case的其中一个关联值的类型为该枚举类型本身，那么我们称之为递归枚举”

摘录来自: “大话Swift 4.0”。 iBooks.

enum MyEnum {
     
    /// 这里value1不指示对它插入间接层，
    /// 因为其关联值不是该枚举类型本身
    case value1(Int)
     
    /// 对value2插入间接层，
    /// 因为其关联值为该枚举类型本身
    indirect case value2(MyEnum)
}
 
/// 这里在IndrectEnum枚举前直接添加indirect关键字，
/// 使得这里面所有的枚举case都插入了间接层。
/// 此时该枚举中的所有枚举case前都不能再放indirect关键字了
indirect enum IndrectEnum {
    case value1(Int)
    case value2(MyEnum)
}

6.枚举中的属性和方法：

/// 这里定义了一个FoodAndDrink枚举
enum MyEnum {
     
    case one(Int)
    case two(Int)
    case three(Int)
     
    /// 在枚举中可以定义初始化器
    init() {
        // 这里默认将当前枚举对象的值作为one枚举值，
        // 其关联值为0
        self = .one(0)
    }
     
    /// 这里定义了一个实例方法fetchValue，
    /// 用于萃取当前枚举值的关联值
    func fetchValue() -> (Int, String) {
        switch self {
        case let .one(value):
            return (value, "one")
             
        case .two(let value):
            return (value, "two")
             
        case .three(let value):
            return (value, "three")
        }
    }
     
    /// 这里定义了一个类型方法，
    /// 根据输入参数的值来返回相应的枚举值
    static func makeEnum(with value: Int) -> MyEnum {
        switch value {
        case 0 ..< 10:
            return .one(value)
             
        case 20 ..< 30:
            return .two(value)
             
        default:
            return .three(value)
        }
    }
     
    /// 这里定义了一个计算式实例属性，
    /// 将当前枚举值设置为two枚举值，
    /// 并带有指定的关联值
    var computedProperty: Int {
        set(i) {
            self = .two(i)
        }
         
        get {
            return self.fetchValue().0
        }
    }
     
    /// 这里定义了一个存储式类型属性
    static var storedTypeProperty: Int = 100
     
    /// 这里定义了一个计算式类型属性
    static var comutedTypeProperty: Int {
        set(i) {
            storedTypeProperty = i
        }
         
        get {
            return storedTypeProperty
        }
    }
}
 
func process[…]