Swift-6.方法

本章包含內容：

• 例項方法
• 型別方法

方法是與某些特定型別相關聯的函式。

• 類、結構體、列舉都可以定義例項方法；例項方法給特定型別的例項封裝了具體的任務與功能（行為）。
• 類、結構體、列舉都可以定義型別方法；型別方法與型別本身相關聯。型別方法與Objective-C中的類方法相似。

在 Objective-C 中，類是唯一能定義方法的型別。但在 Swift 中，你不僅能選擇是否要定義一個類/結構體/列舉，還能靈活地在你建立的型別（類/結構體/列舉）上定義方法。

結構體和列舉能夠定義方法是 Swift 與 C/Objective-C 的主要區別之一。

一、例項方法

1.0 方法

例項方法提供訪問和修改例項屬性的方法或提供與例項目的相關的功能，並且以此來支撐例項的功能。例項方法的語法與函式完全一致。

例項方法能夠隱式訪問它所屬型別的所有的其他例項方法和屬性。例項方法只能被它所屬的類的某個特定例項呼叫。例項方法不能脫離於現存的例項而被呼叫。

下面例子，定義一個很簡單的Counter類，Counter能被用來對一個動作發生的次數進行計數

class Counter {
    
    //宣告一個可變屬性，用它來保持對當前計數器值的追蹤
    var count = 0
    
    //例項方法1.讓計步器按一遞增
    func increment() {
        count += 1
    }
    
    //讓計步器按一個指定的整數值遞增
    func incrememt(by amount:Int) {
        count += amount
    }
    
    //將計步器重置為0
    func reset() {
        count = 0
    }
}

和呼叫屬性一樣，用點語法呼叫例項方法

let counter = Counter()
//初始計數值是0
counter.increment()
//計數值現在是1
counter.incrememt(by: 5)
//計數值現在是6
counter.reset()
//計數值現在是0

函式引數可以同時有一個區域性名稱（在函式體內部使用）和一個外部名稱（在呼叫函式時使用），方法引數也一樣，因為方法就是函式，只是這個函式與某個型別相關聯了。

1.1 self屬性

型別的每一個例項都有一個隱含屬性叫做self，self完全等同於該例項本身。你可以在一個例項的例項方法中使用這個隱含的self屬性來引用當前例項。

上面例子中的increment方法還可以這樣寫：

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

實際上，你不必在你的程式碼裡面經常寫self。不論何時，只要在一個方法中使用一個已知的屬性或者方法名稱，如果你沒有明確地寫self，Swift 假定你是指當前例項的屬性或者方法。

使用這條規則的主要場景是例項方法的某個引數名稱與例項的某個屬性名稱相同的時候。在這種情況下，引數名稱享有優先權，並且在引用屬性時必須使用一種更嚴格的方式。這時你可以使用self屬性來區分引數名稱和屬性名稱。

下面的例子中，self消除方法引數x和例項屬性x之間的歧義：

struct Point {
    var x = 0.0, y = 0.0
    func isToTheRightOfX(x:Double) -> Bool {
        //此時self.x 表示的是結構體定義的變數
        //x 表示的是方法isToTheRightOfX方法的引數
        return self.x > x
    }
}

let somePoint = Point(x: 4.0, y: 5.0)
if somePoint.isToTheRightOfX(x: 1.0){
    print("函式變數x大於引數變數x")
}

如果不使用self字首，Swift 就認為兩次使用的x都指的是名稱為x的函式引數。

1.3 在例項方法中修改值型別

結構體和列舉是值型別。預設情況下，值型別的屬性不能在它的例項方法中被修改。
但是，如果你確實需要在某個特定的方法中修改結構體或者列舉的屬性，你可以為這個方法選擇可變(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("x = \(SomePoint.x), y = \(SomePoint.y)")
輸出"x = 3.0, y = 4.0"

上面的Point結構體定義了一個可變方法 moveByX(_:y:) 來移動Point例項到給定的位置。該方法被呼叫時修改了這個點，而不是返回一個新的點。方法定義時加上了mutating關鍵字，從而允許修改屬性。

注意，不能在結構體型別的常量（a constant of structure type）上呼叫可變方法，因為其屬性不能被改變，即使屬性是變數屬性

let fixedPoint = Point(x: 3.0, y: 3.0)
fixedPoint.moveByX(2.0, y: 3.0)
// 這裡將會報告一個錯誤

1.4 在可變方法中給 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)
    }
}

新版的可變方法moveBy(x:y:)建立了一個新的結構體例項，它的 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
        }
    }
}

var ovenLight = TriStateSwitch.Low
ovenLight.next()
//ovenLight 現在等於 .High
ovenLight.next()
//ovenLight 現在等於 .Off

上面的例子中定義了一個三態開關的列舉。每次呼叫next()方法時，開關在不同的電源狀態（Off，Low，High）之間迴圈切換。

二、型別方法

例項方法是被某個型別的例項呼叫的方法。你也可以定義在型別本身上呼叫的方法，這種方法就叫做型別方法。在方法的func關鍵字之前加上關鍵字static，來指定型別方法。類還可以用關鍵字class來允許子類重寫父類的方法實現。

注意
在 Objective-C 中，你只能為 Objective-C 的類型別（classes）定義型別方法（type-level methods）。在 Swift 中，你可以為所有的類、結構體和列舉定義型別方法。每一個型別方法都被它所支援的型別顯式包含。

型別方法和例項方法一樣用點語法呼叫。但是，你是在型別上呼叫這個方法，而不是在例項上呼叫。下面是如何在SomeClass類上呼叫型別方法的例子：

class SomeClass {
    class func someTypeMethod() {
        //在這裡實現型別方法
    }
}
SomeClass.someTypeMethod()

在型別方法的方法體（body）中，self指向這個型別本身，而不是型別的某個例項。這意味著你可以用self來消除型別屬性和型別方法引數之間的歧義。

一般來說，在型別方法的方法體中，任何未限定的方法和屬性名稱，可以被本類中其他的型別方法和型別屬性引用。一個型別方法可以直接通過型別方法的名稱呼叫本類中的其它型別方法，而無需在方法名稱前面加上型別名稱。類似地，在結構體和列舉中，也能夠直接通過型別屬性的名稱訪問本類中的型別屬性，而不需要前面加上型別名稱。

下面的例子定義了一個名為LevelTracker結構體。它監測玩家的遊戲發展情況（遊戲的不同層次或階段）。這是一個單人遊戲，但也可以儲存多個玩家在同一裝置上的遊戲資訊。

遊戲初始時，所有的遊戲等級（除了等級 1）都被鎖定。每次有玩家完成一個等級，這個等級就對這個裝置上的所有玩家解鎖。LevelTracker結構體用型別屬性和方法監測遊戲的哪個等級已經被解鎖。它還監測每個玩家的當前等級。

struct LevelTracker {
    //儲存玩家已解鎖的最高等級
    static var highestUnlockedLevel = 1
    //每個玩家當前的等級
    var currentLevel = 1
    
    //一旦新等級被解鎖，它會更新highestUnlockedLevel的值
    static func unlock(_ level: Int){
        if level > highestUnlockedLevel {
            highestUnlockedLevel = level
        }
    }
    
    //如果某個給定的等級已經被解鎖，它將返回true
    static func isUnlocked(_ level: Int) -> Bool {
        return level <= highestUnlockedLevel
    }
    
    //這個方法會在更新currentLevel之前檢查所請求的新等級是否已經解鎖。
    //advance(to:)方法返回布林值以指示是否能夠設定currentLevel
    //因為允許在呼叫advance(to:)時候忽略返回值，不會產生編譯警告，所以函式被標註為@ discardableResult屬性
    @discardableResult
    mutating func advance(to level: Int) -> Bool {
        if LevelTracker.isUnlocked(level) {
            currentLevel = level
            return true
        }else{
            return false
        }
    }
}

下面，Player類使用LevelTracker來監測和更新每個玩家的發展進度：

class Player {
    //建立一個新的LevelTracker例項來監測這個使用者的進度
    var tracker = LevelTracker()
    
    let playerName: String
    
    //一旦玩家完成某個指定等級就呼叫它。這個方法為所有玩家解鎖下一等級，並且將當前玩家的進度更新為下一等級。
    //我們忽略了advance(to:)返回的布林值，因為之前呼叫LevelTracker.unlock(_:)時就知道了這個等級已經被解鎖了
    func complete(level: Int) {
        LevelTracker.unlock(level + 1)
        tracker.advance(to: level + 1)
    }
    
    init(name: String) {
        playerName = name
    }
}

你還可以為一個新的玩家建立一個Player的例項，然後看這個玩家完成等級一時發生了什麼：

var player = Player(name: "HO")
player.complete(level: 1);
print("現在解鎖的最高等級為:\(LevelTracker.highestUnlockedLevel)")
輸出："現在解鎖的最高等級為:2"

如果你建立了第二個玩家，並嘗試讓他開始一個沒有被任何玩家解鎖的等級，那麼試圖設定玩家當前等級將會失敗：

player = Player(name: "HO1")
if player.tracker.advance(to: 6){
    print("當前等級:6")
}else{
    print("當前解鎖到的最高等級:\(LevelTracker.highestUnlockedLevel)  6級還沒有被解鎖")
}
輸出："當前等級:2  6級還沒有被解鎖"