Swift中的方法

结构体和美剧能够定义方法是Swift和C/OC的主要区别之一。

1. 实例方法

实例方法是属于某个特定类、结构体或者枚举类型实例的方法。

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

1.1 self属性

类型的每一个实例都有一个隐含的属性叫做self，它完全等同于该实例本身。

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

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

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

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("yes")
}
// print "yes"

1.2 在实例方法中修改值类型

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

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

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

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

1.3 在可变方法中给self赋值

可变方法能够赋给隐含属性self一个全新的实例。

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

调用moveBy(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
        }
    }
}

2. 类型方法

在方法的func关键字之前加上关键字static，来指定类型方法。类还可以用关键字class来允许子类重写父类的方法实现。

struct LevelTracker {
    static var highestUnlockedLevel = 1
    var currentLevel = 1
    
    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
        }
    }
}

注：@discardableResult告诉编译器此方法可以不用接收返回值。

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

Player类创建一个新的LevelTracker实例来检测这个用户的进度。它提供了complete(level:)方法，一旦玩家完成某个指定等级就调用它。