Swift2.0語言教程之類的方法

Swift2.0語言教程之類的方法

Swift2.0語言的方法

方法其實就是函數，只不過它被定義在了類中。在Swift中，根據被使用的方式不一樣，方法分爲了實例方法和類型方法兩種。這兩種方法的定義也和Objective-C是不一樣的。本節依次講解這兩種方法。

Swift2.0語言的實例方法

實例方法被定義在類中，可是由類的實例調用。因此，這類方法被稱爲實例方法。實例方法和函數同樣，分爲了避免帶參數和帶參數兩種。如下依次講解這兩種方法的使用。

1.不帶參數的實例方法

不帶參數的實例方法定義和函數的是同樣的，其語法形式以下：

• func 方法名()->返回值類型{

•   …

• }

但它的調用形式和函數的有所不一樣，其調用形式以下：

• 對象名.方法名()

其中，對象名必須表明的是方法所屬類的實例。

【示例8-13】如下將使用方法輸出字符串"Hello"。代碼以下：

• import Foundation

• class NewClass{

• var str="Hello"

• //方法

•     func printHello(){

•         print(str)

•     }

• }

• let newClass=NewClass()

• newClass.printHello()

運行結果以下所示：

• Hello

2.具備參數的實例方法

具備參數的實例方法就是在方法名後面的括號中添加了參數列表。它的定義也和函數同樣，定義形式以下：

• func 方法名(參數1:數據類型,參數2:數據類型,…)->返回值類型{

•   …

• }

它的調用形式以下：

• 對象名.方法名(參數1,參數2,…)

下面依次講解分別具備一個參數和具備多個參數實例方法的使用方式。

（1）具備一個參數的實例方法

具備一個參數的實例方法是指在參數列表中只有一個參數以及類型。

【示例8-14】下面定義一個類Counter。其中包含了increment()、incrementBy()、reset()方法。代碼以下：

• import Foundation

• class Counter {

•     var count = 0

•     //讓count加1

•     func increment() {

•         count++

•         print(count)

•     }

•     //讓count加一個指定的數值

•     func incrementBy(amount: Int) {

•         count += amount

•         print(count)

•     }

•     //將count設置爲0

•     func reset() {

•         count = 0

•         print(count)

•     }

• }

• let counter = Counter()

• //加1

• counter.increment()

• counter.increment()

• counter.increment()

• //加指定的值

• counter.incrementBy(10)

• //設置爲0

• counter.reset()

其中，increment()方法的功能是自動加1，在每調用一次此方法時，都會在原來值的基礎上增長1；incrementBy()方法是將當前的值和指定的數相加。運行結果以下所示：

• //加1的結果

• 1

• 2

• 3

• //加10的結果

• 13

• //從新進行設置後的結果

• 0

（2）具備多個參數的實例方法

當實例方法的參數列表中包含多個參數時，參數和參數之間須要使用「,」逗號分隔。

【示例8-15】如下將實現兩個數和的計算。代碼以下：

• import Foundation

• class AddClass {

• var count:Int=0

• //計算兩個數的和

•     func add(amount1:Int,amount2:Int){

•         count=amount1+amount2

•         print(count)

•     }

• }

• let counter = AddClass()

• counter.add(5,amount2: 10)

其中，方法add()包含兩個參數amount1和amount2。調用的時候，分別賦值爲5和10。運行結果以下所示：

• 15

注意：1.當方法具備兩個或者兩個以上的參數時，Swift默認僅給方法的第一個參數名稱一個局部參數名稱；默認同時給第二個和後續的參數名稱一個局部參數名稱和外部參數名稱，其中局部參數名稱和外部參數名稱的名稱都是同樣的。若是在調用時，第二個參數以及後續的參數不使用外部參數名，程序就會出現錯誤。以下，

• import Foundation

• class AddClass {

• var count:Int=0

• //計算兩個數的和

•     func add(amount1:Int,amount2:Int){

•         count=amount1+amount2

•         print(count)

•     }

• }

• let counter = AddClass()

• counter.add(5,10)

在此代碼中，實例方法在調用時第二個參數沒有使用外部參數名，致使程序出現以下的錯誤：

• Missing argument label 'amount2:' in call

2.若是開發者不想爲方法的第二個及後續的參數提供外部名稱，能夠經過使用「_」 下劃線做爲該參數的顯式外部名稱，這樣作將覆蓋默認行爲。

【示例8-16】如下將實現兩個數相乘的結果。代碼以下：

• import Foundation

• class MultiplyClass {

•     var count:Int=0

•     func multiply(amount1:Int, _ amount2:Int){

•         count=amount1*amount2

•         print(count)

•     }

• }

• let counter = MultiplyClass()

• counter.multiply(5, 10)

在定義時，第二個參數前加上了「_」下劃線。因此調用的時候，第二個參數能夠省略外部參數名。運行結果以下所示：

• 50

3.對於實例方法的對象，都必須是經過實例去調用的，它不能夠和函數的調用方法同樣去調用，如如下的代碼，此代碼實現的功能是在類中定義一個輸出字符串的方法，而後去調用，代碼以下：

• import Foundation

• class NewClass {

•     func printHello(){

•         print("Hello")

•     }

• }

• printHello()

錯誤信息以下：

• Use of unresolved identifier 'printHello'

Swift2.0語言的類型方法

實例方法是被類的某個實例調用的方法。開發者還能夠定義類自身調用的方法，這種方法被稱爲類型方法（由於類被認爲是一種類型。因此，屬於類的方法，被稱爲類型方法）。定義類型方法須要在func關鍵字以前加上關鍵字class，其通常定義形式以下：

• class 類名 {

•   class func 方法名(參數1:數據類型, 參數1:數據類型,…) {

•     …

•   }

• }

在定義好類型方法後，就能夠進行調用了，其調用的通常形式以下：

• 類名.方法名(參數1,參數2,…)

注意：這裏的方法名爲類型方法名。

1.不帶參數列表的類型方法

不帶參數列表的類型方法就是方法名後面的參數列表中沒有參數。如下定義了一個輸出字符串"Hello"中字符的類型方法。代碼以下：

• import Foundation

• class NewClass {

•     class var str:String{

•         return "Hello"

• }

• //類型方法

•     class func printHello(){

•         for index in str.characters {

•             print(index)

•         }

•     }

• }

• NewClass.printHello()

運行結果以下所示：

• H

• e

• l

• l

• o

2.具備參數的類型方法

具備參數的類型方法是具備參數列表方法。隨着參數的不一樣，能夠將具備參數的類型方法分爲具備一個參數的類型方法和具備多個參數的類型方法。如下就是具備一個參數的類型方法，該方法實現輸出任意字符串的字符。代碼以下：

• import Foundation

• class NewClass {

•     class func printString(str:String){

•         for index in str.characters{

•             print(index)

•         }

•     }

• }

• NewClass.printString("Swift")

運行結果以下所示：

• S

• w

• i

• f

• t

具備多個參數的類型方法說明在參數列表中有多個參數以及類型，參數和參數之間要使用「,」逗號分隔。如下就是定義了多個參數的類型方法，此方法實現了字符串和字符串的鏈接功能。代碼以下：

• import Foundation

• class NewClass {

•    //具備多個參數的類型方法

•     class func joinerString(string:String,toString:String,withjoiner:String){

•         print("str1、str2、str3實現關聯爲：\(string)\(withjoiner)\(toString)")

•      }

• }

• var str1="Hello"

• var str2="Swift"

• var str3="——"

• print("str1=\(str1)")

• print("str2=\(str2)")

• print("str3=\(str3)")

• NewClass.joinerString(str1,toString: str2,withjoiner: str3)

運行結果以下所示：

• str1=Hello

• str2=Swift

• str3=——

• str1、str2、str3實現關聯爲：Hello——Swift

注意：在使用類方法時須要注意如下3點：

（1）存儲屬性

在一個類型方法中不可使用存儲屬性，不然程序就會出現錯誤，如如下的代碼，此代碼實現的是輸出字符串"Hello"。

• import Foundation

• class NewClass {

•     var str="Hello"

•     class func printHello(){

•         for index in str{

•             print(index)

•         }

•     }

• }

• NewClass.printHello()

因爲str是存儲屬性，而printHello()是一個類型方法，在此代碼中將str用在了printHello()方法中，致使程序出現瞭如下的錯誤：

• 'NewClass.Type' does not have a member named 'str'

（2）類調用方法

全部的類型方法必需要使用類去調用，而非對象，不然就會出現錯誤，如如下的代碼：

• import Foundation

• class NewClass {

•     class var str:String{

•         return "Hello"

•     }

•     class func printHello(){

•        for index in str.characters{

•             print(index)

•         }

•     }

• }

• let newClass=NewClass()

• newClass.printHello()

因爲在此代碼中，方法printHello()是一個實例方法，可是在調用時，使用對象進行了調用，致使程序出現瞭如下錯誤：

• 'NewClass' does not have a member named 'printHello'

（3）外部參數名

和實例方法相同， Swift默認給類型方法的第一個參數名稱一個局部參數名稱；默認同時給第二個和後續的參數名稱局部參數名稱和外部參數名稱。在調用時，必定不要忘記外部參數名。

注意：在Swift1.2語言中容許在類中使用關鍵字static定義靜態方法和屬性（所謂靜態屬性或方法是指在程序運行時，分配的內存會一直存在。直到退出程序，內存纔會釋放這塊空間）。其中，靜態屬性的定義以下：

• static var 屬性名:數據類型{

•    …

•    返回一個值

• }

或者爲

• static var 屬性名:數據類型=值

靜態方法的定義以下：

• static func 方法名(參數1:數據類型, 參數1:數據類型,…) ->返回值類型{

•     …

• }

如下將使用static關鍵字在類中聲明一個靜態屬性，其語法形式以下：

• import Foundation

• class NewClass{

•     //靜態屬性

•     static var a:Int{

•         return 100

•     }

• }

• var newclass=NewClass()

• print(NewClass.a)                                                                    //調用靜態屬性

運行結果以下所示：

• 100

存儲屬性、局部變量和全局變量的區別

存儲屬性能夠理解爲變量的一種。因此隨着變量使用地方的不一樣，能夠將變量分爲存儲屬性、局部變量和全局變量。這三種變量的不一樣如表8-1所示。

表8-1  三種變量的不一樣

注意：這裏提到的方法在前面已經講解過了。

【示例8-17】在如下定義了三個類型的變量分別爲str、str1、str2，將它們使用在不一樣的地方。代碼以下：

• import Foundation

• let str="Hello"

• class NewClass {

•     let str1="Swift"

•     func printstring(){

•         let str2="World"

•         print(str)

•         print(str1)

•         print(str2)

•     }

• }

• let newclass=NewClass()

• newclass.printstring()

在此代碼中提到的方法會在以一節中講解。運行結果以下所示：

• Hello

• Swift

• World

注意：在使用存儲屬性、局部變量、和全局變量時必定要注意它們的做用域，所謂做用域就是指這些變量的有效範圍，圖8.5就是以上代碼中變量的有效範圍。

圖8.5  做用域

若是一個變量超出了它的有效範圍，程序就會出現錯誤，如如下的代碼：

• import Foundation

• let str="Hello"

• class NewClass {

•     let str1="Swift"

•     func printstring(){

•         let str2="World"

•         print(str)

•         print(str1)

•         print(str2)

•     }

•     func printstr(){

•         print(str)

•         print(str1)

•         print(str2)

•     }

• }

• let newclass=NewClass()

• newclass.printstring()

在此代碼中str2是一個定義在printstring()方法中的局部變量，因此它的有效範圍就是在此方法中。可是在此方法以外使用會出現錯誤，在此代碼中將str2又使用在了方法printstr()中。致使程序出現瞭如下的出現：

• Use of unresolved identifier 'str2'

局部變量和存儲屬性同名的解決方法——self屬性

在一個類中，方法中的局部變量可能和存儲屬性同名，這是，不能夠直接使用相同的名稱去訪問存儲屬性，爲了解決這一問題，Swift引入了一個self屬性。如如下代碼，此代碼的功能是使用self對存儲屬性進行訪問。代碼以下：

• import Foundation

• class NewClass{

•     var count:Int=100

•     func printcount(){

•         let count:Int=50

•         print(count)

•         print(self.count)

•     }

• }

• let newClass=NewClass()

• newClass.printcount()

count表示的是局部變量的值50，self.count表示存儲屬性的值100。運行結果以下所示：

• 50

• 100

本文選自：Swift2.0語言快速入門v3.0 大學霸內部資料，轉載請註明出處，尊重技術尊重IT人！