• 方法是与某些特定类型相关联的函数。
• 结构体和枚举能够定义方法是 Swift 与 C/Objective-C 的主要区别之一。

实例方法 (Instance Methods)

• 实例方法是属于某个特定类、结构体或者枚举类型实例的方法。需要先创建实例，然后通过这个实例再去访问实例方法。
• 和调用属性一样，用点语法（dot syntax）调用实例方法。
• 类型的每一个实例都有一个隐含属性叫做self，self完全等同于该实例本身。
• 不必在代码里面经常写self。不论何时，只要在一个方法中使用一个已知的属性或者方法名称，如果没有明确地写self，Swift 假定是指当前实例的属性或者方法。
• 当实例方法的某个参数名称与实例的某个属性名称相同的时候，参数名称享有优先权。这时可以使用self属性来区分参数名称和属性名称。
• 结构体和枚举是值类型。默认情况下，值类型的属性不能在它的实例方法中被修改。
• 要使用可变方法，将关键字mutating 放到方法的func关键字之前就可以了。
• 可变方法能够赋给隐含属性self一个全新的实例。
• 不能在结构体类型的常量（a constant of structure type）上调用可变方法，因为其属性不能被改变，即使属性是变量属性。

struct Point {
    var x = 0.0, y = 0.0
    func isToTheRightOfX(x: Double) -> Bool {
        return self.x > x  // 如果不使用self前缀，Swift 就认为两次使用的x都指的是名称为x的函数参数。
    }
    mutating func moveByX(deltaX: Double, y deltaY: Double) {
 //       x += deltaX
 //       y += deltaY   // 改属性
        self = Point(x: x + deltaX, y: y + deltaY) // 该实例本身
    }
}
var somePoint = Point(x: 4.0, y: 5.0)
if somePoint.isToTheRightOfX(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

somePoint = Point(x: 1.0, y: 1.0)
somePoint.moveByX(2.0, y: 3.0)
print("The point is now at (\(somePoint.x), \(somePoint.y))")
// 打印输出: "The point is now at (3.0, 4.0)"

• 枚举的可变方法可以把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
ovenLight.next()
// ovenLight 现在等于 .High
ovenLight.next()
// ovenLight 现在等于 .Off

• 从外部直接设属性很方便，当然struct和enum本身是var的。但是通过方法修改函数却比较麻烦，需要额外标注mutating关键字。
• 实际使用中，struct和enum尽量作为数据结构，作为类的属性。行为定义的事情还是交给类来做
• 尽量减少mutating的使用，用方法修改属性的事情尽量少做。可以增加计算属性来达到相同的效果
• struct和enum修改self，形成新实例，成为新成员的方式可以多用用，这在某些特殊场合比较合适。

类型方法 (Type Methods)

• 在方法的func关键字之前加上关键字static，来指定类型方法。类还可以用关键字class来允许子类重写父类的方法实现。
• 可以为所有的类、结构体和枚举定义类型方法。每一个类型方法都被它所支持的类型显式包含。
• 类型方法和实例方法一样用点语法调用。但是，是在类型上调用这个方法，而不是在实例上调用。用类型名直接调用，而不是用实例名。
• 在类型方法的方法体（body）中，self指向这个类型本身，而不是类型的某个实例。这意味着可以用self来消除类型属性和类型方法参数之间的歧义。
• 类型方法可以直接通过名称调用自己的类型方法和类型属性，而无需在类型方法或者类型属性名称前面加上类型名称。

struct LevelTracker {
    static var highestUnlockedLevel = 1
    static func unlockLevel(level: Int) {
        if level > highestUnlockedLevel { highestUnlockedLevel = level }
    }
    static func levelIsUnlocked(level: Int) -> Bool {
        return level <= highestUnlockedLevel  // 类型方法可以直接访问自己类型属性（或者方法），不需要加类型名称
    }
    var currentLevel = 1
    
    mutating func advanceToLevel(level: Int) -> Bool {
        if LevelTracker.levelIsUnlocked(level) {  // 实例方法不能直接访问类型属性（或者方法），需要加类型名称
            currentLevel = level
            return true
        } else {
            return false
        }
    }
}

class Player {
    var tracker = LevelTracker()
    let playerName: String
    func completedLevel(level: Int) {
        LevelTracker.unlockLevel(level + 1)
        tracker.advanceToLevel(level + 1)
    }
    init(name: String) {
        playerName = name
    }
}

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

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