Swift learning part 11 - 方法

方法是与某些特定类型相关联的函数。类、结构体、枚举都可以定义实例方法；实例方法为给定类型的实例封装了具体的任务与功能。类、结构体、枚举也可以定义类型方法；类型方法与类型本身相关联。类型方法与 Objective-C 中的类方法（class methods）相似。

结构体和枚举能够定义方法是 Swift 与 C/Objective-C 的主要区别之一。在 Objective-C 中，类是唯一能定义方法的类型。但在 Swift 中，你不仅能定义一个类/结构体/枚举，还能灵活地在你创建的类型（类/结构体/枚举）上定义方法。

实例方法（Instance Methods）

实例方法是属于某个特定类、结构体或者枚举类型实例的方法。实例方法提供访问和修改实例属性的方法或提供与实例目的相关的功能，并以此来支撑实例的功能。实例方法的语法与函数完全一致。

实例方法要写在它所属的类型的前后大括号之间。实例方法能够隐式访问它所属类型的所有的其他实例方法和属性。实例方法只能被它所属的类的某个特定实例调用。实例方法不能脱离于现存的实例而被调用。

下面的例子，定义一个很简单的Counter类，Counter能被用来对一个动作发生的次数进行计数：

class Counter {
    var count = 0
    func increment() {
        count += 1
    }
    func increment(by amount: Int) {
        count += amount
    }
    func reset() {
        count = 0
    }
}

和调用属性一样，用点语法调用实例方法：

let counter = Counter() // 初始计数值是0
counter.increment() // 计数值现在是1
counter.increment(by: 5) // 计数值现在是6
counter.reset() // 计数值现在是0

self 属性

类型的每一个实例都有一个隐含属性叫做 self，self 完全等同于该实例本身。可以在一个实例的实例方法中使用这个隐含的 self 属性来引用当前实例。

上面例子中的increment方法还可以这样写：

func increment() {
    self.count += 1
}

实际上，你不必在你的代码里面经常写self。不论何时，只要在一个方法中使用一个已知的属性或者方法名称，如果你没有明确地写self，Swift 假定你是指当前实例的属性或者方法。这种假定在上面的Counter中已经示范了：Counter中的三个实例方法中都使用的是count（而不是self.count）。

使用这条规则的主要场景是实例方法的某个参数名称与实例的某个属性名称相同的时候。在这种情况下，参数名称享有优先权，并且在引用属性时必须使用一种更严格的方式。这时你可以使用self属性来区分参数名称和属性名称。

下面的例子中，self消除方法参数x和实例属性x之间的歧义：

struct Point {
    var x = 0.0, y = 0.0
    func isToTheRightOfX(x: Double) -> Bool {
        return self.x > x
    }
}
let somePoint = Point(x: 4.0, y: 5.0)
if somePoint.isToTheRightOfX(x: 1.0) {
    print("This point is to the right of the line where x == 1.0")
}
// 打印“This point is to the right of the line where x == 1.0”

如果不使用self前缀，Swift 就认为两次使用的x都指的是名称为x的函数参数。

在实例方法中修改值类型

结构体和枚举是值类型。默认情况下，值类型的属性不能在它的实例方法中被修改。

但是，如果你确实需要在某个特定的方法中修改结构体或者枚举的属性，你可以为这个方法选择可变(mutating)行为，然后就可以从其方法内部改变它的属性；并且这个方法做的任何改变都会在方法执行结束时写回到原始结构中。方法还可以给它隐含的self属性赋予一个全新的实例，这个新实例在方法结束时会替换现存实例。

要使用可变方法，将关键字mutating 放到方法的func关键字之前就可以了：

struct AnotherPoint {
    var x = 0.0, y = 0.0
    mutating func moveByX(deltaX: Double, y deltaY: Double) {
        x += deltaX
        y += deltaY
    }
}
var anotherPoint = AnotherPoint(x: 1.0, y: 1.0)
anotherPoint.moveByX(deltaX: 2.0, y: 3.0)
print("The point is now at (\(anotherPoint.x), \(anotherPoint.y))")
// 打印 "The point is now at (3.0, 4.0)"

上面的Point结构体定义了一个可变方法 moveByX(_:y:) 来移动Point实例到给定的位置。该方法被调用时修改了这个点，而不是返回一个新的点。方法定义时加上了mutating关键字，从而允许修改属性。

注意：不能在结构体类型的常量上调用可变方法，因为其属性不能被改变，即使属性是变量属性。

let fixedPoint = AnotherPoint(x: 3.0, y: 3.0)
fixedPoint.moveByX(2.0, y: 3.0) // 这里将会报告一个错误

在可变方法中给 self 赋值

可变方法能够赋给隐含属性self一个全新的实例。上面Point的例子可以用下面的方式改写：

struct AnotherPoint_ {
    var x = 0.0, y = 0.0
    mutating func moveBy(x deltaX: Double, y deltaY: Double) {
        self = AnotherPoint_(x: x + deltaX, y: y + deltaY)
    }
}

新版的可变方法moveBy(x:y:)创建了一个新的结构体实例，它的 x 和 y 的值都被设定为目标值。调用这个版本的方法和调用上个版本的最终结果是一样的。

枚举的可变方法可以把self设置为同一枚举类型中不同的成员：

enum TriStateSwitch {
    case Off, Low, High
    mutating func next() {
        switch self {
        case .Off:
            self = .Low
        case .Low:
            self = .High
        case .High:
            self = .Off
        }
    }
}
var ovenLight = TriStateSwitch.Low
print("ovenLight address is \(Unmanaged.passUnretained(ovenLight as AnyObject).toOpaque())")
ovenLight.next() // ovenLight 现在等于 .High
print("ovenLight address is \(Unmanaged.passUnretained(ovenLight as AnyObject).toOpaque())")
ovenLight.next() // ovenLight 现在等于 .Off
print("ovenLight address is \(Unmanaged.passUnretained(ovenLight as AnyObject).toOpaque())")
// 三次打印地址的结果不同，ovenLight 通过可变方法被赋予了其全新的实例对象

类型方法

可以定义在类型本身上调用的方法，这种方法叫做类型方法。在方法的 func 关键字之前加上关键字 static 来指定类型方法，类还可以用关键字 class 来允许子类重写父类的方法。

注意：在 Swift 中，可以为所有的类、结构体和枚举定义类型方法，每一个类型方法都被它所支持的类型显示包含。

在类型方法的方法体中，self 指向这个类型本身，而不是类型的某个实例。类型方法和实例方法一样用点语法调用：

class SomeClass {
    class func someMethod() {
        // 在这里实现类型方法
    }
}
SomeClass.someMethod()

下面的例子定义了一个名为 LevelTracker 的结构体，用以检测玩家的游戏发展情况：

struct LevelTracker {
    static var highestUnlockedLevel = 1 //监测玩家已解锁的最高等级
    var currentLevel = 1 // 实例属性 currentLevel 用来监测每个玩家当前的等级
    
    static func unlock(_ level: Int) {
        if level > highestUnlockedLevel {
            highestUnlockedLevel = level
        }
    }
    
    static func isUnlocked(_ level: Int) -> Bool {
        return level <= highestUnlockedLevel
    }
    
    @discardableResult
    mutating func advance(to level: Int) -> Bool {
        if LevelTracker.isUnlocked(level) {
            currentLevel = level
            return true
        } else {
            return false
        }
    }
    // advance(to:)方法返回布尔值以指示是否能够设置currentLevel。
    // 因为允许在调用advance(to:)时忽略返回值而不会产生编译警告，所以函数被标注为@ discardableResult属性
}

下面的 Player 类使用 LevelTracker 来监测和更新每个玩家的发展进度：

class Player {
    var tracker = LevelTracker()
    let playerName: String
    
    func complete(level: Int) {
        LevelTracker.unlock(level + 1)
        tracker.advance(to: level + 1)
    }
    
    init(name: String) {
        playerName = name
    }
}

Player类创建一个新的LevelTracker实例来监测这个用户的进度。它提供了complete(level:)方法，一旦玩家完成某个指定等级就调用它。这个方法为所有玩家解锁下一等级，并且将当前玩家的进度更新为下一等级。我们忽略了advance(to:)返回的布尔值，因为之前调用LevelTracker.unlock(_:)时就知道了这个等级已经被解锁了）。

你还可以为一个新的玩家创建一个Player的实例，然后看这个玩家完成等级一时发生了什么：

var player = Player(name: "Argyrios")
player.complete(level: 1)
print("highest unlocked level is now \(LevelTracker.highestUnlockedLevel)")
// 打印 "highest unlocked level is now 2"

如果你创建了第二个玩家，并尝试让他开始一个没有被任何玩家解锁的等级，那么试图设置玩家当前等级将会失败：

player = Player(name: "Beto")
if player.tracker.advance(to: 6) {
    print("player is now on level 6")
} else {
    print("level 6 has not yet been unlocked")
}
// 打印 "level 6 has not yet been unlocked"