Swift 编程语言 入门学习笔记（7~9）

1~6链接 [url]http://liyunpeng.iteye.com/blog/2076529[/url]
[color=red]七、枚举和结构体[/color]
Swift中，使用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 {
        case .Ace:
            return "ace"
        case .Jack:
            return "jack"
        case .Queen:
            return "queen"
        case .King:
            return "king"
        default:
            return String(self.toRaw())
        }
    }
}
let ace = Rank.Ace
let aceRawValue = ace.toRaw()

if let convertedRank = Rank.fromRaw(11) {
    let threeDescription = convertedRank.simpleDescription()
}

使用toRaw和fromRaw方法来转换在原始值和枚举值，上面的例子在第一句中设置了枚举的原始值，后面的值会依次按照原始值赋值
我们也可以不给他设置原始值，直接使用枚举，代码如下

enum Suit {
    case Spades, Hearts, Diamonds, Clubs
    func simpleDescription() -> String {
        switch self {
        case .Spades:
            return "spades"
        case .Hearts:
            return "hearts"
        case .Diamonds:
            return "diamonds"
        case .Clubs:
            return "clubs"
        }
    }
}
let hearts = Suit.Hearts
let heartsDescription = hearts.simpleDescription()

在以上的这段代码里面，我们可以看到两种引用枚举值的方式，也就是在枚举内部的方法里，可以直接使用.Hearts来引用Hearts值，默认可以省去self，而在外面则需要写全部的Suit.Hearts

使用struck关键字创建结构体，结构体和类大部分是相同的，最大不同的地方是结构体在传递的时候完全是新的副本，而类则是传递的引用
更多的不同，可以参看如下博客，写的比较详细
[url]http://blog.youkuaiyun.com/supergerm/article/details/29969785[/url]
一个枚举可以在不同的实例有不同的值，例如代码如下

enum ServerResponse {
    case Result(String, String)
    case Error(String)
}

let success = ServerResponse.Result("6:00 am", "8:09 pm")
let failure = ServerResponse.Error("Out of cheese.")

switch success {
case let .Result(sunrise, sunset):
    let serverResponse = "Sunrise is at \(sunrise) and sunset is at \(sunset)."
case let .Error(error):
    let serverResponse = "Failure...  \(error)"
}

[color=red]八、协议与扩展[/color]
定义协议，使用protocol关键字，协议类似于Java中的接口interface定义，类、枚举和结构体可以采用协议，代码如下

protocol ExampleProtocol {
    var simpleDescription: String { get }
    mutating func adjust()
}


class SimpleClass: ExampleProtocol {
    var simpleDescription: String = "A very simple class."
    var anotherProperty: Int = 69105
    func adjust() {
        simpleDescription += "  Now 100% adjusted."
    }
}
var a = SimpleClass()
a.adjust()
let aDescription = a.simpleDescription

struct SimpleStructure: ExampleProtocol {
    var simpleDescription: String = "A simple structure"
    mutating func adjust() {
        simpleDescription += " (adjusted)"
    }
}
var b = SimpleStructure()
b.adjust()
let bDescription = b.simpleDescription

其中涉及到关键字 mutating ，这个关键字在官方文档里面解释，是当结构体或者枚举类型中的方法定义，修改self的值的时候，需要在方法定义前面加这个关键字

可以使用协议的名字来定义类型，比如如下
let protocolValue: ExampleProtocol = a
protocolValue.simpleDescription

面向对象的基本特征，这个就不用太多说了！

[color=red]九、泛型[/color]
Swift中使用角括号<>来定义泛型方法或者类型，例如代码如下

func repeat<ItemType>(item: ItemType, times: Int) -> ItemType[] {
    var result = ItemType[]()
    for i in 0..times {
        result += item
    }
    return result
}
repeat("knock", 4)

以上的代码中ItemType代表泛型的类型，而参数中和返回值的ItemType，则代表传进来的泛型类型，原本是未知的，而传进来是什么则就是什么类型，类似于<T>
我们可以定义泛型给函数方法、类、枚举和结构体

// Reimplement the Swift standard library's optional type
enum OptionalValue<T> {
    case None
    case Some(T)
}
var possibleInteger: OptionalValue<Int> = .None
possibleInteger = .Some(100)

以上这段代码就是Swift中的Optional类型的定义，我们定义?的类型就是定义了Optional这样一种类型
我们还可以通过关键字where来给泛型里面加一些条件限制，就像在SQL中书写where条件差不多一个意思，例如代码如下

func anyCommonElements <T, U where T: Sequence, U: Sequence, T.GeneratorType.Element: Equatable, T.GeneratorType.Element == U.GeneratorType.Element> (lhs: T, rhs: U) -> Bool {
    for lhsItem in lhs {
        for rhsItem in rhs {
            if lhsItem == rhsItem {
                return true
            }
        }
    }
    return false
}
anyCommonElements([1, 2, 3], [3])

以上代码中，Equatable是实现对比的协议接口，可以通过以下代码来了解一下

struct MyStruct: Equatable {
    var name = "Untitled"
}
func == (lhs: MyStruct, rhs: MyStruct) -> Bool {
    return lhs.name == rhs.name
}

let value1 = MyStruct()
var value2 = MyStruct()
let firstCheck = value1 == value2
// firstCheck is true

value2.name = "A New Name"
let secondCheck = value1 == value2
// secondCheck is false

那么我们就可以看出来了，要求T和U都是序列类型的，并且属性符合Equatable这个协议或者说叫实现这个接口

大体上Swift的入门语法就这么多了，后续还需要慢慢得学习，如果有不对的地方，还请大师指点修正！！