Swift5.x- 方法（中文文档）

引言

继续学习Swift文档，从上一章节：属性，咱们学习了Swift属性相关的内容，如存储属性和计算属性set和get、懒加载、属性监听willSet和didSet、属性包装@propertyWrapper、全局和局部变量在懒加载上的区别、类属性等这些内容。如今，咱们学习Swift的方法相关的内容。因为篇幅较长，这里分篇来记录，接下来，Fighting！

这一章节的内容比较简单，熟悉的朋友能够直接跳到下一章节：下标

方法

方法是与特定类型关联的函数。 类，结构体和枚举均可以定义实例方法，这些实例方法封装了用于处理给定类型的实例的特定任务和功能。 类，结构体和枚举也能够定义与类型自己关联的类型方法。 类型方法相似于Objective-C中的类方法。

结构体和枚举能够在Swift中定义方法这一事实与C和Objective-C的主要不一样之处。 在Objective-C中，类是惟一能够定义方法的类型。 在Swift中，您能够选择是定义类，结构体仍是枚举，而且仍然能够灵活地在建立的类型上定义方法。

1 实例方法

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

您能够在实例方法的所属类型的大括号内编写一个实例方法。 实例方法能够隐式访问该类型的全部其余实例方法和属性。 实例方法只能在其所属类型的特定实例上调用。 没有现有实例，就不能单独地调用它。

这是定义一个简单的Counter类的示例，该类可用于计算操做发生的次数：

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

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

• increment()方法次数加1。
• increment(by: Int)方法增长指定的次数。
• reset()方法将次数重置为0。

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 复制代码

函数参数能够具备名称（供在函数体内使用）和参数标签（供在调用函数时使用），如Function Argument Labels and Parameter Names中所述。 方法参数也是如此，由于方法只是与类型关联的函数。

1.1 self属性

一个类型的每一个实例都有一个称为self的隐式属性，它与该实例自己彻底等效。 您可使用self属性在其本身的实例方法中引用当前实例。

上例中的increment()方法能够这样写：

func increment() {
    self.count += 1
}
复制代码

实际上，您不须要常常在代码中编写自我。 若是您未明确编写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的方法参数。

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

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

可是，若是须要在特定方法中修改结构体或枚举的属性，则能够选择对该方法进行行为更改。 而后，该方法能够从方法内部更改（即更改）其属性，并在方法结束时将其所作的任何更改写回到原始结构。 该方法还能够为其隐式的self属性分配一个全新的实例，而且该新实例将在方法结束时替换现有实例。

您能够经过将mutating关键字放在该方法的func关键字以前来选择这种行为：

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)"
复制代码

上面的Point结构体定义了一个可变的moveBy（x：y :)方法，该方法将Point实例移动必定量。 实际上，此方法不是返回新的点，而是修改了在其上被调用的点。 将mutating关键字添加到其定义中，以使其可以修改其属性。

请注意，您不能在结构体类型的常量上调用可变的（mutating）方法，由于它的属性即便是可变属性也没法更改，如“常量结体构实例的存储属性”中所述：

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

1.3 在mutating方法中分配self

可变方法能够为隐式的self属性分配一个全新的实例。 上面显示的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)
    }
}
复制代码

此版本的mutableBy（x：y :)方法将建立一个新结构体，其x和y值设置为目标位置。 调用此方法的替代版本的最终结果将与调用早期版本的结果彻底相同。

枚举的可变方法能够将隐式self参数设置为与相同枚举的不一样的case：

enum s {
    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
复制代码

本示例定义了三态开关的枚举。 每次调用next（）方法时，开关都会在三种不一样的电源状态（关，低和高）之间循环。

2 类方法

如上所述，实例方法是您在特定类型的实例上调用的方法。 您还能够定义在类型自己上调用的方法。 这些方法称为类方法。 您能够经过在方法的func关键字以前写入static关键字来指示类方法。 类能够改用class关键字，以容许子类覆盖父类对该方法的实现。

注意
在Objective-C中，您只能为Objective-C类定义类型级别的方法。 在Swift中，您能够为全部类，结构体和枚举定义类型级别的方法。 每一个类方法都明确地限定于它支持的类型。

类方法使用点语法来调用，就像实例方法同样。 可是，您在类型上而不是在该类型的实例上调用类方法。 在名为SomeClass的类上调用类方法的方法以下：

class SomeClass {
    class func someTypeMethod() {
        // type method implementation goes here
    }
}
SomeClass.someTypeMethod()
复制代码

在类方法的主体内，隐式self属性是指类型自己，而不是该类型的实例。这意味着您可使用self来区分类型属性和类方法参数，就像处理实例属性和实例方法参数同样。

通常而言，您在类方法主体内使用的任何不符合的方法和属性名称都将引用其余类型级别的方法和属性。一个类方法可使用另外一个方法的名称来调用另外一个类方法，而无需在其前面加上类型名称。一样，结构体和枚举上的类方法可使用类型属性的名称访问类型属性，而无需使用类型名称前缀。

下面的示例定义了一个称为LevelTracker的结构体，该结构体可跟踪玩家在游戏的不一样关卡或阶段中的进度。这是一款单人游戏，但能够在单个设备上存储多个玩家的信息。

首次玩游戏时，全部游戏级别（除了第一级）都被锁定。每当玩家完成一个关卡时，设备上的全部玩家都将解锁该关卡。 LevelTracker结构体使用类型属性和方法来跟踪游戏的哪些级别已解锁。它还跟踪单个玩家的当前级别。

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结构体跟踪全部玩家已解锁的最高级别。 此值存储在名为maximumUnlockedLevel的类型属性中。

LevelTracker还定义了两个类型函数，以与highestUnlockedLevel属性一块儿使用。 第一个是称为unlock（_ :)的类型函数，每当解锁新级别时，该函数都会更新highestUnlockedLevel的值。 第二个是方便类型的函数，称为isUnlocked（_ :)，若是特定级别的数字已被解锁，则返回true。 （请注意，这些类型方法能够访问maximumUnlockedLevel类型属性，而无需将其编写为LevelTracker.highestUnlockedLevel。）

除了其类型属性和类方法以外，LevelTracker还能够跟踪单个玩家在游戏中的进度。 它使用称为currentLevel的实例属性来跟踪玩家当前正在玩的级别。

为了帮助管理currentLevel属性，LevelTracker定义了一个称为advance（to :)的实例方法。 在更新currentLevel以前，此方法检查所请求的新级别是否已被解锁。 advance（to :)方法返回一个布尔值，以指示它是否实际上可以设置currentLevel。 因为调用advance（to :)忽略返回值不必定是错误的代码，所以此函数标有@discardableResult属性。 有关此属性的更多信息，请参见Attributes。

LevelTracker结构体与Player类一块儿使用，以下所示，用于跟踪和更新单个玩家的进度：

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

Player类建立一个新的LevelTracker实例来跟踪该玩家的进度。 它还提供了一种称为complete（level :)的方法，只要玩家完成特定的关卡，就会调用该方法。 此方法为全部玩家解锁下一个级别，并更新玩家的进度以将他们移至下一个级别。 （由于已知该级别已被上一行的LevelTracker.unlock（_ :)调用解锁，因此会忽略advance（to :)的布尔返回值。）

您能够为新玩家建立Player类的实例，并查看当玩家完成第一级时会发生什么：

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"
复制代码

总结

这一章节内容比较简单，主要是实例方法和类方法的定义和使用；这里特别说一下swift里的类方法定义使用static关键词，还可使用class关键词修饰方法，表示子类的方法能够覆盖父类的方法。还有结构体和枚举里的方法，默认状况下是不能够修改结构体和枚举里定义的属性的，不过可使用mutating关键词修饰方法，达到修改属性的目的。

最后，有收获的朋友麻烦动动手指点个赞哦，谢谢~

上一章节：属性

下一章节：下标

参考文档：Swift - Methods