iOS开发之Swift学习（二）

文章目录：
（1）对象和类
（2）枚举和结构体
（3）协议和扩展
（4）泛型

（1）对象和类

1. 要创建一个类的实例，在类名后面加上括号。使用点语法来访问实例的属性和方法。

class Shape {
    var numberOfSides = 0
    func simpleDescription() -> String {
        return "A shape with \(numberOfSides) sides."
    }
}
var shape = Shape()
shape.numberOfSides = 7
var shapeDescription = shape.simpleDescription()

2. 构造函数来初始化类实例。使用 init 来创建一个构造器。

3. 如果你需要在删除对象之前进行一些清理工作，使用 deinit 创建一个析构函数。

4. 子类的定义方法是在它们的类名后面加上父类的名字，用冒号分割。创建类的时候并不需要一个标准的根类，所以你可以忽略父类。

5. 子类如果要重写父类的方法的话，需要用 override 标记——如果没有添加 override 就重写父类方法的话编译器 会报错。编译器同样会检测 override 标记的方法是否确实在父类中。

6. 处理变量的可选值时，可以在操作(比如方法、属性和子脚本)之前加 ? 。如果 ? 之前的值是 nil ， ? 后面 的东西都会被忽略，并且整个表达式返回 nil 。否则， ? 之后的东西都会被运行。在这两种情况下，整个表达式 的值也是一个可选值。

（2）枚举和结构体

1. 使用 enum 来创建一个枚举。和其他所有命名类型一样，枚举可以包含方法。
2. 一个枚举成员的实例可以有实例值。相同枚举成员的实例可以有不同的值。创建实例的时候传入值即可。实例值和原始值是不同的:枚举成员的原始值对于所有实例都是相同的，而且在定义枚举的时候设置原始值。

 enum ServerResponse {
     case Result(String, String)
     case Failure(String)
}
 let success = ServerResponse.Result("6:00 am", "8:09 pm")
 let failure = ServerResponse.Failure("Out of cheese.")
 switch success {
 case let .Result(sunrise, sunset):
     let serverResponse = "Sunrise is at \(sunrise) and sunset is at \(sunset)."
 case let .Failure(message):
     print("Failure...  \(message)")
 }

3. 使用 struct 来创建一个结构体。结构体和类有很多相同的地方，比如方法和构造器。它们之间最大的一个区别就 是结构体是传值，类是传引用。

struct Card {
     var rank: Rank
     var suit: Suit
     func simpleDescription() -> String {
          return "The \(rank.simpleDescription()) of \(suit.simpleDescription())"
} }
 let threeOfSpades = Card(rank: .Three, suit: .Spades)
 let threeOfSpadesDescription = threeOfSpades.simpleDescription()

（3）协议和扩展

1. 使用 protocol 来声明一个协议。

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

2. 类、枚举和结构体都可以实现协议。

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

注意: 声明 SimpleStructure 时候 mutating 关键字用来标记一个会修改结构体的方法。 SimpleClass 的声明不需要 标记任何方法，因为类中的方法通常可以修改类属性(类的性质)。

3. 使用 extension 来为现有的类型添加功能，比如新的方法和计算属性。你可以使用扩展在别处修改定义，甚至是 从外部库或者框架引入的一个类型，使得这个类型遵循某个协议。

extension Int: ExampleProtocol {
    var simpleDescription: String {
        return "The number \(self)"
    }
    mutating func adjust() {
self += 42 }
}
 print(7.simpleDescription)

可以像使用其他命名类型一样使用协议名——例如，创建一个有不同类型但是都实现一个协议的对象 合。当处理类型是协议的值时，协议外定义的方法不可用。

let protocolValue: ExampleProtocol = a print(protocolValue.simpleDescription)
// print(protocolValue.anotherProperty) // 去掉注释可以看到错误

即使 protocolValue 变量运行时的类型是 simpleClass ，编译器会把它的类型当做 ExampleProtocol 。这表示你不能调用类在它实现的协议之外实现的方法或者属性。

（4）泛型

1. 在尖括号里写一个名字来创建一个泛型函数或者类型。

func repeatItem<Item>(repeating item: Item, numberOfTimes: Int) -> [Item] {
    var result = [Item]()
    for _ in 0..<numberOfTimes {
        result.append(item)
    }
    return result
}
repeatItem(repeating: "knock", numberOfTimes:4)

2. 我们也可以创建泛型函数、方法、类、枚举和结构体。

// 重新实现 Swift 标准库中的可选类型 enum OptionalValue<Wrapped> {
case None
     case Some(Wrapped)
 }
 var possibleInteger: OptionalValue<Int> = .None
 possibleInteger = .Some(100)

3. 在类型名后面使用 where 来指定对类型的需求，比如，限定类型实现某一个协议，限定两个类型是相同的，或者 限定某个类必须有一个特定的父类。

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

<T: Equatable> 和 <T> ... where T: Equatable> 是等价的。