在Swift中，类，结构体，枚举，都能定义实例方法。

结构和枚举可以在Swift中定义方法的事实是与C和Objective-C的主要区别。 在Objective-C中，类是唯一可以定义方法的类型。 在Swift中，您可以选择是否定义类，结构或枚举，并且仍然可以灵活地根据所创建的类型定义方法。

实例方法

实例方法是属于特定类，结构或枚举的实例的函数。 它们通过提供访问和修改实例属性的方式，或通过提供与实例的目的相关的功能来支持这些实例的功能。 实例方法具有与函数完全相同的语法，如函数中所述。

你在它所属类型的开始和结束括号内写入一个实例方法。 实例方法具有对该类型的所有其他实例方法和属性的隐式访问。 实例方法只能在其所属类型的特定实例上调用。 它不能在没有现有实例的情况下单独调用。

下面是一个定义一个简单的Counter类的例子，它可以用来计算一个动作发生的次数：

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

Counter类定义了三个实例方法：

• increment（）将count递增1。
• increment（by：Int）将count增加指定的整数值。
• reset（）将count重置为零。

Counter类还声明一个变量属性count，以跟踪当前计数器的值。

您使用与属性相同的点语法调用实例方法：

let counter = Counter()
// the initial counter value is 0
counter.increment()
// the counter's value is now 1
counter.increment(by: 5)
// the counter's value is now 6
counter.reset()
// the counter's value is now 0

函数参数可以具有名称（用于函数主体中）和参数标签（用于调用函数时），如函数参数标签和参数名称中所述。 方法参数也是如此，因为方法只是与类型相关联的函数。

self关键字

每个类型的实例都有一个名为self的隐式属性，它完全等同于实例本身。 您可以使用self属性在自己的实例方法中引用当前实例。

在上面的例子中的increment（）方法可以这样写：

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

在实践中，你不需要经常在代码中写self。 如果你没有明确的写self，Swift假定你是指的当前实例的属性或方法，当你在方法中使用已知的属性或方法名称。 这个假设通过在Counter的三个实例方法中使用count（而不是self.count）来证明。

当实例方法的参数名称与该实例的属性具有相同的名称时，会发生此规则的主要异常。 在这种情况下，参数名称优先，必须以更有条件的方式引用属性。 您可以使用self属性来区分参数名称和属性名称。

这里，self消除了在称为x的方法参数和也称为x的实例属性之间的歧义：

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

没有self前缀，Swift将假定x的两个使用都引用称为x的方法参数。

在实例方法中修改值类型

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

但是，如果您需要在特定方法中修改结构或枚举的属性，则可以选择对该方法进行突变行为。 然后，该方法可以在方法内改变（即改变）其属性，并且当该方法结束时，它所做的任何改变被写回到原始结构。 该方法还可以为其隐式自我属性分配一个完全新的实例，并且当该方法结束时，这个新实例将替换现有实例。

您可以通过在该方法的func关键字之前放置mutating关键字来选择此行为：

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

请注意，您不能在常量的结构类型上mutating变异方法，因为它的属性不能更改，即使它们的属性是变量。

下面是一个错误的示例

let fixedPoint = Point(x: 3.0, y: 3.0)
fixedPoint.moveBy(x: 2.0, y: 3.0)
// this will report an error

在mutating方法中给自己赋值

mutating方法可以向隐式自我属性分配一个全新的实例。 上面显示的Point示例可以用以下方式编写：

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 :)方法创建一个全新的结构。 调用此方法的替代版本的最终结果将与调用较早版本完全相同。

枚举的变化方法可以将隐式自参数设置为与同一枚举的不同情况：

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 is now equal to .high
ovenLight.next()
// ovenLight is now equal to .off

类型(类、静态)方法

如上所述，实例方法是在特定类型的实例上调用的方法。 您还可以定义在类型本身上调用的方法。 这些类型的方法称为类型方法。 通过在方法的func关键字之前写入static关键字来指示类型方法。 类也可以使用class关键字来允许子类覆盖超类的该方法的实现。

类型方法使用点语法调用，如实例方法。 但是，您可以在类型上调用类型方法，而不是在该类型的实例上调用。 下面是如何在一个名为SomeClass的类调用类型方法：

class SomeClass {
    class func someTypeMethod() {
        // type method implementation goes here
    }
}
SomeClass.someTypeMethod()

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
        }
    }
}

LevelTracker还定义了两个类型函数，以使用highestUnlockedLevel属性。 第一个是一个名为unlock（_ :)的类型函数，当一个新的级别被解锁时，它更新highestUnlockedLevel的值。 第二个是一个方便类型函数，称为isUnlocked（_ :)，如果特定级别数字已解锁，则返回true。 （请注意，这些类型方法可以访问highestUnlockedLevel类型属性，而不需要将其写为LevelTracker.highestUnlockedLevel。）

LevelTracker结构与Player类一起使用，如下所示，用于跟踪和更新单个播放器的进度：

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
    }
}

var player = Player(name: "Argyrios")
player.complete(level: 1)
print("highest unlocked level is now \(LevelTracker.highestUnlockedLevel)")
// Prints "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")
}
// Prints "level 6 has not yet been unlocked"