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人！