方法是与特定类型相关联的函数。
类、结构和枚举都可以定义实例方法，这些方法封装了处理给定类型实例的特定任务和功能。
类、结构和枚举还可以定义与类型本身关联的类型方法。类型方法类似于Objective-C中的类方法。
结构和枚举可以在Swift中定义方法，这是与C和Objective-C的主要区别。在Objective-C中，类是唯一可以定义方法的类型。在Swift中，您可以选择是定义类、结构还是枚举，并且仍然可以灵活地定义所创建类型的方法。
Instance Methods 实例方法
实例方法是属于特定类、结构或枚举的实例的函数。它们支持这些实例的功能，或者提供访问和修改实例属性的方法，或者提供与实例用途相关的功能。实例方法与函数具有完全相同的语法，如函数中所述。
在其所属类型的开括号和闭括号中编写实例方法。实例方法可以隐式访问该类型的所有其他实例方法和属性。实例方法只能在其所属类型的特定实例上调用。如果没有现有实例，就不能单独调用它。
下面的例子定义了一个简单的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() 将计数器重置为零。
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
函数参数可以同时具有名称(用于函数体中)和参数标签(用于调用函数时)。因为方法只是与Type 相关联的函数。
The self Property 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")
}
如果没有self前缀，Swift会假设x的两种用法都引用了名为x的方法参数。编译器将会报错。
Modifying Value Types from Within Instance Methods 从实例方法中修改值类型
结构和枚举是值类型。默认情况下，值类型的属性不能从其实例方法中修改。
但是，如果需要在特定方法中修改值类型属性（结构体和枚举），则可以选择修改该方法的行为。然后，方法可以从方法内部修改(即更改)它的属性，当方法结束时，它所做的任何更改都会被写回原始结构。该方法还可以为它的隐式self属性分配一个全新的实例，这个新实例将在方法结束时替换现有的实例。
您可以通过在该方法的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)"
上面的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
Assigning to self Within a Mutating Method 在一个可变方法中给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:)方法创建了一个新结构，其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
这个例子定义了一个三态开关的枚举。每次调用next()方法时，开关在三种不同的电源状态(off、low和high)之间循环。
Type Methods
如上所述，实例方法是对特定类型的实例调用的方法。
您还可以定义在类型本身上调用的方法。这些类型的方法称为类型方法。
通过在方法的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
}
}
}
关卡跟踪器结构跟踪任何玩家解锁的最高关卡。该值存储在名为highestUnlockedLevel的类型属性中。
LevelTracker还定义了两个类型函数来使用highestUnlockedLevel属性。第一个类型函数名为unlock(:)，每当解锁一个新级别时，它都会更新highestUnlockedLevel的值。第二个是一个名为isunlock(:)的便利类型函数，如果某个特定的级别号已经被解锁，那么它将返回true。(注意，这些类型方法可以访问highestUnlockedLevel类型属性，而不需要将其编写为leveltrack .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 complete(level: Int) {
LevelTracker.unlock(level + 1)
tracker.advance(to: level + 1)
}
init(name: String) {
playerName = name
}
}
Player类创建一个新的LevelTracker实例来跟踪该播放器的进程。它还提供了一个名为complete(level:)的方法，该方法在玩家完成特定关卡时调用。该方法为所有玩家解锁下一关，并更新玩家的进程以将他们移动到下一关。(将忽略advance(to:)的布尔返回值，因为已知该级别已通过调用leveltrack .unlock(_:)在前一行解锁。
你可以为一个新玩家创建一个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"
网友评论