Swift 3.0

一、对象和类

Swift 当中使用class和类名来创建一个类。类中属性的声明和常量、变量声明一样，唯一的区别就是它们的上下文是类。同样，方法和函数声明也一样。

class TestViewController: ViewController {    var numberOfSides = 0    func simpleDescription() -> String {        return "A shape with \(numberOfSides) sides"    }}

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

        var vc = ViewController()        vc.numberOfSides = 8        var s = vc.returnFifteen()

这个版本的ViewContrller类缺少了一些重要的东西：一个构造函数来初始化类实例。使用init来创建一个构造器。

class NamedShape {    var numberOfSides: Int = 0      var name: String    init(name: String) {        self.name = name}    func simpleDescription() -> String {        return "A shape with \(numberOfSides) sides."} }

注意 self 被用来区别实例变量。当你创建实例的时候，像传入函数参数一样给类传入构造器的参数。每个属性都 需要赋值——无论是通过声明(就像 numberOfSides )还是通过构造器(就像 name )。

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

class Square: NamedShape {    var sideLength: Double    init(sideLength: Double, name: String) {        self.sideLength = sideLength        super.init(name: name)        numberOfSides = 4}    func area() ->  Double {        return sideLength * sideLength}    override func simpleDescription() -> String {        return "A square with sides of length \(sideLength)."} }let test = Square(sideLength: 5.2, name: "my test square")test.area()test.simpleDescription()

除了储存简单的属性之外，属性可以有getter和setter。

class EquilateralTriangle: NamedShape {    var sideLength: Double = 0.0    init(sideLength: Double, name: String) {        self.sideLength = sideLength        super.init(name: name)        numberOfSides = 3}var perimeter: Double {        get {            return 3.0 * sideLength        }        set {            sideLength = newValue / 3.0} }    override func simpleDescription() -> String {        return "An equilateral triagle with sides of length \(sideLength)."} }var triangle = EquilateralTriangle(sideLength: 3.1, name: "a triangle")print(triangle.perimeter)triangle.perimeter = 9.9print(triangle.sideLength)

在perimeter的setter中，新值的名字是newValue。你可以在set之后显示的设置一个名字。
注意 EquilateralTriangle 类的构造器执行了三步:
1. 设置子类声明的属性值
2. 调用父类的构造器
3. 改变父类定义的属性值。其他的工作比如调用方法、getters 和 setters 也可以在这个阶段完成。

二、枚举和结构体

使用enum来创建一个枚举。就像类和其他所有命名类型一样，枚举可以包含方法。

enum Rank:Int {    case Ace = 1    case Two,Three,Four,Five,Six,Seven    case Jack,Queen,King    func simpleDescription() -> String {        switch self {        case .Ace:            return "ace"        case .Two:            return "two"        case .Queen:            return "queen"        default:            return String(self.rawValue)        }    }}let ace = Rank.Acelet aceRawValue = ace.rawValue

默认情况下，Swift按照从0开始每次加1的方式为原始值进行赋值，不过你可以通过显式赋值进行改变。在上面的栗子中，Ace被显式赋值为1，并且剩下的原始值会按照顺序赋值。你也可以使用字符串或者浮点数作为枚举的原始值。使用rawValue属性来访问一个枚举成员的原始值。

使用init?(rawValue:) 初始化构造器在原始值和枚举值之间进行转换。

if let convertedRank = Rank(rawValue: 3) {            let threeDescription = convertedRank.simpleDescription()        }

枚举的成员值是实际值，并不是原始值的另一种表达方法。实际上，如果没有比较有意义的原始值，你就不需要提供原始值。

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.Heartslet heartDesciption = hearts.simpleDescription()

注意，有两种方式可以引用Hearts 成员：给hearts 常量赋值时，枚举成员Suit.Hearts 需要用全名来引用，因为常量没有显示指定类型。在switch 里，枚举成员使用缩写.Hearts 来引用，因为self的值已经知道一个suit。已知变量类型的情况下你可以使用缩写。

一个枚举成员的实例可以有实例值。相同枚举成员的实例可以有不同的值，创建实例的时候传入值即可。实例值和原始值是不同的：枚举成员的原始值对于所有实例都是相同的，而且你是在定义枚举的时候设置原始值。

举个栗子，考虑从服务器获取日出和日落的时间。服务器会返回正常结果或者错误信息。

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

注意，日升和日落是如何从SeverResponse中提取到并且与switch的case相匹配的。

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

三、协议和扩展

使用protocol 来声明一个协议。

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.simpleDescriptionstruct 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 的声明不需要 标记任何方法，因为类中的方法通常可以修改类属性(类的性质)。

使用 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 。这表示你不 能调用类在它实现的协议之外实现的方法或者属性。