Swift 函数

函数

初始化函数

在 Swift 的类中，声明的所有非可选择类型的变量都要进行初始化，可以在声明的时候初始化，也可以在初始化函数中进行。

如下，定义一个 Person 类：

class Person: NSObject {
    let name:String
    var age:Int?
    
    init(name:String) {
        
        self.name = name
        super.init()
    }
    
    deinit {
        print("Person deinit")
    }
}

在 Swift 类中，可以使用 override 关键字来重写父类中的方法，而在重写初始化函数时，需要注意，调用父类中当前函数的顺序是有限制的。

如下，定义一个 Person 的子类 Student ：

class Student: Person {
    var studentNo:String
    
    required override init(name: String) {
        self.studentNo = "####"
        super.init(name: name)
    }
    
    convenience init(name: String,studentNo: String) {
        self.init(name: name)
        self.studentNo = studentNo
    }
}    

在重写的 init 函数中，调用父类的 init 函数，需要在为当前子类中所有的非可选择类型属性初始化之后进行，否则会编译错误。

如果在一个类中需要声明不同的初始化方法，那么注意不可以相互调用，除非使用 convenience 关键字进行修饰。而且，初始化当前子类中的属性要放在调用其他初始化函数之后进行。

并且，使用 convenience 修饰的初始化函数是不可以被重写的，也不可以在子类的初始化函数中被调用。而且，不能使用其初始化一个子类实例。

但是，如果子类重写了该初始化函数调用的初始化函数，那么子类便可以直接使用这个被 convenience 关键字修饰的函数初始化实例了。

所以，如果有必要，可以使用 required 关键字来修饰被调用的初始化函数，从而使子类必须重写该函数，进而使被 convenience 关键字修饰的函数可以被子类使用。

如下，定义一个 Student 的子类 ForeignStudent ：

class ForeignStudent: Student {
    var country:String?
    
    init(name:String,studentNo:String,country:String="USA") {
        self.country = country
        super.init(name: name)
        self.studentNo = studentNo
        print(self.name, "is from",self.country!,"and it's student number is",self.studentNo)
    }
    
    required init(name: String) {
        
        self.country = "USA"
        super.init(name: name)
    }
    
    func changeInfo(_ age:Int,_ studentNo:String="####",_ country:String="USA") -> Void {
        self.age = age
        self.studentNo = studentNo
        self.country = country
        print(self.name, "," ,self.age!,"years old ,is from",self.country!,"and it's student number is",self.studentNo)
    }
}

如果使用 required 进行了修饰，那么隐含了该函数是对父类中函数的重写，所以可以省略 override 关键字。

从该子类中的新定义的初始化函数可知，修改父类中的属性，需要在调用了父类的初始化函数之后进行。

执行下面的函数：

func test() {
	let foreignStudent1 = ForeignStudent(name: "John", studentNo: "1001", country:"Canada")
	        
	foreignStudent1.changeInfo(18, "1002")
	    
	let foreignStudent2 = ForeignStudent(name: "Matin", studentNo: "1004")
	    
	foreignStudent2.changeInfo(18, "1004")
}	

得到结果：

John is from Canada and it's student number is 1001
John , 18 years old ,is from USA and it's student number is 1002
Matin , 18 years old ,is from USA and it's student number is 1004

从这两个初始化函数的调用可知，虽然一个函数的参数具有默认值在调用时可以省略，但是如果类中定义了同省略后的函数有相同参数标签的函数，或者忽略了参数标签而函数名相同的函数，那么实际执行的并不是这个省略了参数的函数，而是实际定义的函数。

就如同此处，执行的是 convenience init(name: String,studentNo: String) 函数，而不是 init(name:String,studentNo:String,country:String="USA") 省略了最后一个参数的函数一样。

实例函数和类函数

不同于 Objective-C 中，通过 + 和 - 来区分实例方法和类方法，在 Swift 中，使用 static 或 class 关键字修饰的函数表示类函数，否则就表示声明的函数是实例函数。

class TestClass: NSObject {
	
	static func test1() {}
	class func test2() {}
	func test3() {}
}

类似的，调用这两种类型的函数，只是使用类还是类的实例的区别。

TestClass.test1()
TestClass.test2()
TestClass.init().test3()