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

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