Swift文法學習之 方法

標籤：

方法:1.執行個體方法(OC中執行個體方法,通過建立執行個體調用) 2.類型方法(OC中的類方法,類名調用)

類、結構體、枚舉都可以定義執行個體方法和類型方法；執行個體方法為給定類型的執行個體封裝了具體的任務與功能。類型方法與類型本身相關聯。類型方法與 Objective-C 中的類方法（class methods）相似。

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

執行個體方法(Instance Methods)

執行個體方法是屬於某個特定類、結構體或者枚舉類型執行個體的方法。執行個體方法提供訪問和修改執行個體屬性的方法或提供與執行個體目的相關的功能，並以此來支撐執行個體的功能。

執行個體方法要寫在它所屬的類型的前後大括弧之間。執行個體方法能夠隱式訪問它所屬類型的所有的其他執行個體方法和屬性。執行個體方法只能被它所屬的類的某個特定執行個體調用。執行個體方法不能脫離於現存的執行個體而被調用。

// 執行個體方法的建立
class Counter {
// 可變屬性
var count = 0
// 三個執行個體方法
func increment() {
count++
}
func incrementBy(amount: Int) {
count += amount
}
func reset() {
count = 0
}
}

// 執行個體方法的調用 通過建立執行個體打點調用
let counter = Counter()
counter.increment()
counter.incrementBy(5)
counter.reset()
方法的局部參數名稱和外部參數名稱(Local and External Parameter Names for Methods)

方法參數與函數參數一樣(因為方法就是函數，只是這個函數與某個類型相關聯了,可以同時有一個局部名稱（在函數體內部使用）和一個外部名稱（在調用函數時使用).）。但是，方法和函數的局部名稱和外部名稱的預設行為是不一樣的。
Swift 中的方法和 Objective-C 中的方法極其相似。像在 Objective-C 中一樣，Swift 中方法的名稱通常用一個介詞指向方法的第一個參數，比如：with，for，by等等。前面的Counter類的例子中incrementBy方法就是這樣的。介詞的使用讓方法在被調用時能像一個句子一樣被解讀。和函數參數不同，對於方法的參數，Swift 使用不同的預設處理方式，這可以讓方法命名規範更容易寫。

具體來說，Swift 預設僅給方法的第一個參數名稱一個局部參數名稱;預設同時給第二個和後續的參數名稱局部參數名稱和外部參數名稱。這個約定與典型的命名和呼叫慣例相適應， 與你在寫 Objective-C 的方法時很相似。這個約定還讓運算式方法在調用時不需要再限定參數名稱。

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

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

incrementBy方法有兩個參數： amount和numberOfTimes。預設情況下，Swift 只把amount當作一個局部名稱，但是把numberOfTimes即看作局部名稱又看作外部名稱。下面調用這個方法：

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

你不必為第一個參數值再定義一個外部變數名：因為從函數名incrementBy已經能很清楚地看出它的作用。但是第二個參數，就要被一個外部參數名稱所限定，以便在方法被調用時明確它的作用。

這種預設的行為能夠有效處理方法（method）,類似於在參數numberOfTimes前寫一個井號（#）：

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

這種預設行為使上面代碼意味著：在 Swift 中定義方法使用了與 Objective-C 同樣的文法風格，並且方法將以自然運算式的方式被調用。

修改方法的外部參數名稱(Modifying External Parameter Name Behavior for Methods)

有時為方法的第一個參數提供一個外部參數名稱是非常有用的，儘管這不是預設的行為。你可以自己添加一個顯式的外部名稱或者用一個井號（#）作為第一個參數的首碼來把這個局部名稱當作外部名稱使用。

相反，如果你不想為方法的第二個及後續的參數提供一個外部名稱，可以通過使用底線（_）作為該參數的顯式外部名稱，這樣做將覆蓋預設行為。
func incrementBy(amount: Int, numberOfTimes: Int,:Int,:String) {
count += amount * numberOfTimes
}

self屬性(The self Property)

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

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

func increment() {
self.count++
}
當執行個體方法的某個參數名稱與執行個體的某個屬性名稱相同的時候。在這種情況下，參數名稱享有優先權，並且在引用屬性時必須使用一種更嚴格的方式。這時你可以使用self屬性來區分參數名稱和屬性名稱。
下面的例子中，self消除方法參數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”)
}
// 輸出 “This point is to the right of the line where x == 1.0”（這個點在x等於1.0這條線的右邊）

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

在執行個體方法中修改實值型別(Modifying Value Types from Within Instance Methods)

結構體和枚舉是實值型別。一般情況下，實值型別的屬性不能在它的執行個體方法中被修改。

需要在某個具體的方法中修改結構體或者枚舉的屬性，你可以選擇變異(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(2.0, y: 3.0)
println(“The point is now at ((somePoint.x), (somePoint.y))”)
// 輸出 “The point is now at (3.0, 4.0)”
上面的Point結構體定義了一個變異方法（mutating method）moveByX，moveByX用來移動點。moveByX方法在被調用時修改了這個點，而不是返回一個新的點。方法定義時加上mutating關鍵字,這才讓方法可以修改實值型別的屬性。

注意：不能在結構體類型常量上調用變異方法，因為常量的屬性不能被改變，即使想改變的是常量的變數屬性也不行

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建立了一個新的結構（它的 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）之前迴圈切換。

類型方法(Type Methods)

執行個體方法是被類型的某個執行個體調用的方法。你也可以定義類型本身調用的方法，這種方法就叫做類型方法。
聲明類的類型方法，在方法的func關鍵字之前加上關鍵字class；
聲明結構體和枚舉的類型方法，在方法的func關鍵字之前加上關鍵字static。

注意：在 Objective-C 裡面，你只能為 Objective-C 的類定義類型方法（type-level methods）。在 Swift 中，你可以為所有的類、結構體和枚舉定義類型方法：每一個類型方法都被它所支援的類型顯式包含。
類型方法和執行個體方法一樣用點文法調用。但是，你是在類型層面上調用這個方法，而不是在執行個體層面上調用。下面是如何在SomeClass類上調用類型方法的例子：

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

在類型方法的方法體（body）中，self指向這個類型本身，而不是類型的某個執行個體。
對於結構體和枚舉來說，這意味著你可以用self來消除靜態屬性和靜態方法參數之間的歧義（類似於我們在前面處理執行個體屬性和執行個體方法參數時做的那樣）。
一般來說，任何未限定的方法和屬性名稱，將會來自於本類中另外的類型層級的方法和屬性。一個類型方法可以調用本類中另一個類型方法的名稱，而無需在 方法名稱前面加上類型名稱的首碼。同樣，結構體和枚舉的類型方法也能夠直接通過靜態屬性的名稱訪問靜態屬性，而不需要類型名稱首碼。

遊戲初始時，所有的遊戲等級（除了等級 1）都被鎖定。每次有玩家完成一個等級，這個等級就對這個裝置上的所有玩家解鎖。LevelTracker結構體用靜態屬性和方法監測遊戲的哪個等級已經被解鎖。它還監測每個玩家的當前等級。
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監測玩家的已解鎖的最高等級。這個值被儲存在靜態屬性highestUnlockedLevel中。

LevelTracker還定義了兩個類型方法與highestUnlockedLevel配合工作。第一個類型方法是unlockLevel：一旦新等級被解鎖，它會更新highestUnlockedLevel的值。第二個類型方法是levelIsUnlocked：如果某個給定的等級已經被解鎖，它將返回true。（注意：儘管我們沒有使用類似LevelTracker.highestUnlockedLevel的寫法，這個類型方法還是能夠訪問靜態屬性highestUnlockedLevel）

除了靜態屬性和類型方法，LevelTracker還監測每個玩家的進度。它用執行個體屬性currentLevel來監測玩家當前的等級。

為了便於管理currentLevel屬性，LevelTracker定義了執行個體方法advanceToLevel。這個方法會在更新currentLevel之前檢查所請求的新等級是否已經解鎖。advanceToLevel方法返回布爾值以指示是否能夠設定currentLevel。

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

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類建立一個新的LevelTracker執行個體來監測這個使用者的發展進度。它提供了completedLevel方法：一旦玩家完成某個指定等級就調用它。這個方法為所有玩家解鎖下一等級，並且將當前玩家的進度更新為下一等級。（我們忽略了advanceToLevel返回的布爾值，因為之前調用LevelTracker.unlockLevel時就知道了這個等級已經被解鎖了）。

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

var player = Player(name: “Argyrios”)
player.completedLevel(1)
println(“highest unlocked level is now (LevelTracker.highestUnlockedLevel)”)
// 輸出 “highest unlocked level is now 2”（最高等級現在是2）

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

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”)
}
// 輸出 “level 6 has not yet been unlocked”（等級6還沒被解鎖）

Swift文法學習之 方法