Swift編程語言中文教程（十一）：Swift方法（Methods）的使用

---

方法(Methods)

方法是與某些特定類型相關(guān)聯(lián)的功能/函數(shù)。類、結(jié)構(gòu)體、枚舉都可以定義實例方法；實例方法為指定類型的實例封裝了特定的任務(wù)與功能。類、結(jié)構(gòu)體、枚舉也可以定義類(型)方法(type itself)；類型方法與類型自身相關(guān)聯(lián)。類型方法與Objective-C中的類方法(class methods)相似。

在Swift中,結(jié)構(gòu)體和枚舉能夠定義方法；事實上這是Swift與C/Objective-C的主要區(qū)別之一。在Objective-C中,類是唯一能定義方法的類型。在Swift中，你能夠選擇是否定義一個類/結(jié)構(gòu)體/枚舉，并且你仍然享有在你創(chuàng)建的類型(類/結(jié)構(gòu)體/枚舉)上定義方法的靈活性。

實例方法(Instance Methods)

實例方法是某個特定類、結(jié)構(gòu)體或者枚舉類型的實例的方法。實例方法支撐實例的功能: 或者提供方法,以訪問和修改實例屬性;或者提供與實例的目的相關(guān)的功能。實例方法的語法與函數(shù)完全一致，參考函數(shù)說明。

實例方法要寫在它所屬的類型的前后括號之間。實例方法能夠訪問他所屬類型的所有的其他實例方法和屬性。實例方法只能被它所屬的類的特定實例調(diào)用。實例方法不能被孤立于現(xiàn)存的實例而被調(diào)用。

下面是定義一個很簡單的類Counter的例子(Counter能被用來對一個動作發(fā)生的次數(shù)進行計數(shù)):

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

Counter類定理了三個實例方法：

• increment讓計數(shù)器按一遞增；
• incrementBy(amount: Int)讓計數(shù)器按一個指定的整數(shù)值遞增；
• reset將計數(shù)器重置為0。

Counter這個類還聲明了一個可變屬性count，用它來保持對當前計數(shù)器值的追蹤。

和調(diào)用屬性一樣，用點語法(dot syntax)調(diào)用實例方法:

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

<h3 "="">方法的局部參數(shù)名稱和外部參數(shù)名稱(Local and External Parameter Names for Methods)

函數(shù)參數(shù)有一個局部名稱(在函數(shù)體內(nèi)部使用)和一個外部名稱(在調(diào)用函數(shù)時使用),參考External Parameter Names。對于方法參數(shù)也是這樣，因為方法就是函數(shù)(只是這個函數(shù)與某個類型相關(guān)聯(lián)了)。但是，方法和函數(shù)的局部名稱和外部名稱的默認行為是不一樣的。

Swift中的方法和Objective-C中的方法極其相似。像在Objective-C中一樣，Swift中方法的名稱通常用一個介詞指向方法的第一個參數(shù)，比如：with,for,by等等。前面的Counter類的例子中incrementBy方法就是這樣的。介詞的使用讓方法在被調(diào)用時能像一個句子一樣被解讀。Swift這種方法命名約定很容易落實,因為它是用不同的默認處理方法參數(shù)的方式，而不是用函數(shù)參數(shù)(來實現(xiàn)的)。

具體來說，Swift默認僅給方法的第一個參數(shù)名稱一個局部參數(shù)名稱;但是默認同時給第二個和后續(xù)的參數(shù)名稱局部參數(shù)名稱和外部參數(shù)名稱。 這個約定與典型的命名和調(diào)用約定相匹配，這與你在寫Objective-C的方法時很相似。這個約定還讓expressive method調(diào)用不需要再檢查/限定參數(shù)名。

看看下面這個Counter的替換版本（它定義了一個更復雜的incrementBy方法）：

class Counter {    var count: Int = 0    func incrementBy(amount: Int, numberOfTimes: Int) {      count += amount * numberOfTimes    }  }  

incrementBy方法有兩個參數(shù)： amount和numberOfTimes。默認地，Swift只把amount當作一個局部名稱，但是把numberOfTimes即看作本地名稱又看作外部名稱。下面調(diào)用這個方法：

let counter = Counter()  counter.incrementBy(5, numberOfTimes: 3)  // counter value is now 15  

你不必為第一個參數(shù)值再定義一個外部變量名：因為從函數(shù)名incrementBy已經(jīng)能很清楚地看出它的目的/作用。但是第二個參數(shù)，就要被一個外部參數(shù)名稱所限定,以便在方法被調(diào)用時讓他目的/作用明確。

這種默認的行為能夠有效的檢查方法，比如你在參數(shù)numberOfTimes前寫了個井號( # )時:

func incrementBy(amount: Int, #numberOfTimes: Int) {   count += amount * numberOfTimes  }  

這種默認行為使上面代碼意味著：在Swift中定義方法使用了與Objective-C同樣的語法風格，并且方法將以自然表達式的方式被調(diào)用。

修改外部參數(shù)名稱(Modifying External Parameter Name Behavior for Methods)

有時為方法的第一個參數(shù)提供一個外部參數(shù)名稱是非常有用的，盡管這不是默認的行為。你可以自己添加一個明確的外部名稱;你也可以用一個hash符號作為第一個參數(shù)的前綴，然后用這個局部名字作為外部名字。

相反，如果你不想為方法的第二個及后續(xù)的參數(shù)提供一個外部名稱，你可以通過使用下劃線(_)作為該參數(shù)的顯式外部名稱來覆蓋默認行為。

self屬性(The self Property)

類型的每一個實例都有一個隱含屬性叫做self，它完全等同于這個實力變量本身。你可以在一個實例的實例方法中使用這個隱含的self屬性來引用當前實例。

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

func increment() {    self.count++  }  

實際上，你不必在你的代碼里面經(jīng)常寫self。不論何時，在一個方法中使用一個已知的屬性或者方法名稱，如果你沒有明確的寫self，Swift假定你是指當前實例的屬性或者方法。這種假定在上面的Counter中已經(jīng)示范了：Counter中的三個實例方法中都使用的是count(而不是self.count)

這條規(guī)則的主要例外發(fā)生在當實例方法的某個參數(shù)名稱與實例的某個屬性名稱相同時。 在這種情況下，參數(shù)名稱享有優(yōu)先權(quán)，并且在引用屬性時必須使用一種更恰當(被限定更嚴格)的方式。 你可以使用隱藏的self屬性來區(qū)分參數(shù)名稱和屬性名稱。

下面的例子演示了self消除方法參數(shù)x和實例屬性x之間的歧義：

struct Point {    var x = 0.0, y = 0.0    func isToTheRightOfX(x: Double) -> Bool {      return self.x > x    }  }  let somePoint = Point(x: 4.0, y: 5.0)  if somePoint.isToTheRightOfX(1.0) {    println("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的函數(shù)參數(shù)。

在實例方法中修改值類型(Modifying Value Types from Within Instance Methods)

結(jié)構(gòu)體和枚舉是值類型。一般情況下，值類型的屬性不能在他的實例方法中被修改。

但是，如果你確實需要在某個具體的方法中修改結(jié)構(gòu)體或者枚舉的屬性，你可以選擇變異(mutating)這個方法。方法可以從內(nèi)部變異它的屬性；并且它做的任何改變在方法結(jié)束時都會回寫到原始結(jié)構(gòu)。方法會給它隱含的self屬性賦值一個全新的實例,這個新實例在方法結(jié)束后將替換原來的實例。

要變異方法, 將關(guān)鍵字mutating 放到方法的func關(guān)鍵字之前就可以了：

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(2.0, y: 3.0)  println("The point is now at (\(somePoint.x), \(somePoint.y))")  // prints "The point is now at (3.0, 4.0)"  

上面的Point結(jié)構(gòu)體定義了一個變異方法(mutating method)moveByX，moveByX用來移動一個point。moveByX方法在被調(diào)用時修改了這個point,而不是返回一個新的point。方法定義是加上那個了mutating關(guān)鍵字,所以方法可以修改值類型的屬性了。

注意：不能在結(jié)構(gòu)體類型的常量上調(diào)用變異方法,因為常量的屬性不能被改變,就算你想改變的是常量的可變屬性也不行，參考Stored Properties of Constant Structure Instances

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

在變異方法中給self賦值(Assigning to self Within a Mutating Method)

變異方法能夠賦給隱含屬性self一個全新的實例。上面Point的例子可以用下面的方式改寫：

struct Point {    var x = 0.0, y = 0.0    mutating func moveByX(deltaX: Double, y deltaY: Double) {      self = Point(x: x + deltaX, y: y + deltaY)    }  }  

新版的變異方法moveByX創(chuàng)建了一個新的分支結(jié)構(gòu)(他的x和y的值都被設(shè)定為目標值了)。調(diào)用這個版本的方法和調(diào)用上個版本的最終結(jié)果是一樣的。

枚舉的變異方法可以讓self從相同的枚舉設(shè)置為不同的成員。

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  

上面的例子中定義了一個三態(tài)開關(guān)的枚舉。每次調(diào)用next方法時，開關(guān)在不同的電源狀態(tài)(Off,Low,High)之前循環(huán)切換。

類型方法(Type Methods)

實例方法是被類型的某個實例調(diào)用的方法。你也可以定義類列本身調(diào)用的方法，這種方法就叫做類型方法。聲明類的類型方法，在方法的func關(guān)鍵字之前加上關(guān)鍵字class；聲明結(jié)構(gòu)體和枚舉的類型方法，在方法的func關(guān)鍵字之前加上關(guān)鍵字static。

注意：

在Objective-C里面，你只能為Objective-C的類定義類型方法(type-level methods)。在Swift中，你可以為所有的類、結(jié)構(gòu)體和枚舉定義類型方法：Each type method is explicitly scoped to the type it supports.

類型方法和實例方法一樣用點語法調(diào)用。但是，你是在類型上調(diào)用這個方法，而不是在實例上調(diào)用。下面是如何在SomeClass類上調(diào)用類型方法的例子：

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

在類型方法的方法體(body)中，self指向這個類型本身，而不是類型的某個實例。對于結(jié)構(gòu)體和枚舉來說，這意味著你可以用self來消除靜態(tài)屬性和靜態(tài)方法參數(shù)之間的二意性(類似于我們在前面處理實例屬性和實例方法參數(shù)時做的那樣)。

一般地，在類型方法里面所使用的任何未限定的方法和屬性名稱，將會指向其他的類型級別的方法和屬性。一個類型方法可以用另一個類型方法的名稱調(diào)用踏，而無需在方法名稱前面加上類型名稱的前綴。同樣，結(jié)構(gòu)體和枚舉的類型方法也能夠直接通過靜態(tài)屬性的名稱訪問靜態(tài)屬性，而不需要類型名稱前綴。

下面的例子定義了一個名為LevelTracker結(jié)構(gòu)體。它監(jiān)測玩家的發(fā)展情況(游戲的不同層次或階段)。這是一個單人游戲，但也可以用作多玩家游戲中單個設(shè)備上的信息存儲。

游戲初始時，所有的游戲等級(除了等級1)都被鎖定。每次有玩家完成一個等級，這個等級就對這個設(shè)備上的所有玩家解鎖。LevelTracker結(jié)構(gòu)體用靜態(tài)屬性和方法監(jiān)測游戲的哪個等級已經(jīng)被解鎖。他還監(jiān)測每個玩家的當前等級。

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

LevelTracker監(jiān)測玩家的已解鎖的最高等級。這個值被存儲在靜態(tài)屬性highestUnlockedLevel中。

LevelTracker還定義了兩個類型方法與highestUnlockedLevel配合工作。第一個類型方法是unlockLevel：一旦新等級被解鎖，它會更新highestUnlockedLevel的值。第二個類型方法是levelIsUnlocked：如果某個給定的等級已經(jīng)被解鎖，他返回true。(注意：我們沒用使用LevelTracker.highestUnlockedLevel，這個類型方法還是能夠訪問靜態(tài)屬性highestUnlockedLevel)

除了靜態(tài)屬性和類型方法，LevelTracker還監(jiān)測每個玩家的進度。它用實例屬性currentLevel來監(jiān)測玩家當前正在進行的等級。

為了便于管理currentLevel屬性，LevelTracker定義了實例方法advanceToLevel。這個方法會在更新currentLevel之前檢查所請求的新等級是否已經(jīng)解鎖。advanceToLevel方法返回布爾值以指示是否確實能夠設(shè)置currentLevel了。

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

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

Player類創(chuàng)建一個新的LevelTracker實例來檢測這個用戶的發(fā)展進度。他提供了completedLevel方法：一旦玩家完成某個指定等級就調(diào)用它。這個方法為所有玩家解鎖下一等級，并且將當前玩家的進度更新為下一等級。（我們忽略了advanceToLevel返回的布爾值，因為之前調(diào)用LevelTracker.unlockLevel時就知道了這個等級已經(jīng)被解鎖了）

你還可以為一個新的玩家創(chuàng)建一個Player的實例，然后看這個玩家完成等級一時發(fā)生了什么：

var player = Player(name: "Argyrios")  player.completedLevel(1)  println("highest unlocked level is now \(LevelTracker.highestUnlockedLevel)")  // prints "highest unlocked level is now 2"  

如果你創(chuàng)建了第二個玩家，并嘗試讓他開始一個沒有被任何玩家解鎖的等級，你試圖去設(shè)置玩家當前等級時會失敗的：

player = Player(name: "Beto")  if player.tracker.advanceToLevel(6) {  println("player is now on level 6")  } else {  println("level 6 has not yet been unlocked")  }  // prints "level 6 has not yet been unlocked"

本文資源來自互聯(lián)網(wǎng)，由本網(wǎng)整理編輯，供大家學習參考。因為技術(shù)有限，可能會有不足及錯誤，請大家指正。