Swift 构造函数(Initializer)

在本教程中，我们将通过实例了解 Swift 构造函数(Initializer)及其类型。

Initializer 是一种特殊类型的函数，用于创建类或结构的对象。

在 Swift 中，我们使用 init() 方法创建构造函数(Initializer)。例如，

class Wall {
  ...
  // create an initializer
  init() {
    // perform initialization
    ...
  }
}

这里，方法 init() 是类 Wall 的构造函数。

实例：初始化

// declare a class
class  Wall {
  var length: Double
  // initializer to initialize property
  init() {
    length = 5.5
    print("Creating a wall.")
    print("Length = ", length)
  }
}
// create an object
var wall1 = Wall()

结果如下:

Creating a wall.
Length =  5.5

在上面的实例中，我们创建了一个名为 init() 的构造函数。在构造函数中，我们已经初始化了 length 属性的值。

请注意以下语句：

// create an object
var wall1 = Wall()

这里，当创建 wall1 对象时，将调用 init() 构造函数。并且，length 属性的值初始化为 5.5。

---

参数化初始化

Swift 构造函数也可以接受一个或多个参数。这种初始化称为参数化初始化（带参数的初始化）。

让我们看一个例子，

class Wall {
  var length: Double
  ...
  // initializer with parameter
  init(length: Double) {
    self.length = length
  }
}
// create an object
var wall1 = Wall(length: 10.5)

这里，

init(length: Double) - 设定参数长度的初始化

var wall1 = Wall(length: 10.5) - 将值 10.5 传递给参数 length

self.length = length 将 length 长度参数 (10.5) 的值赋值给 length 属性

self.length - 指定 length 属性与当前对象 wall1 关联

实例：参数化初始化

// declare a class
class Wall {
  var length: Double
  var height: Double
  // parameterized initializer to initialize properties
  init(length: Double, height: Double) {
    self.length = length
    self.height = height
  }
  func calculateArea() -> Double {
    return length * height
  }
}
// create object and initialize data members
var wall1 = Wall(length: 10.5, height: 8.6)
var wall2 = Wall(length: 8.5, height: 6.3)
print("Area of Wall 1: ", wall1.calculateArea())
print("Area of Wall 2: ", wall2.calculateArea())

结果如下:

Area of Wall 1:  90.3
Area of Wall 2:  53.55

在上面的实例中，我们创建了一个初始化程序 init()，其中包含两个参数：length 和 height。请注意这些表达式，

var wall1 = Wall(length: 10.5, height: 8.6)
var wall2 = Wall(length: 8.5, height: 6.3)

在这里，在创建 Wall 类的对象时，我们将成员属性的值作为参数传递。

通过初始化成员变量，我们现在可以使用 calculateArea() 方法计算墙的面积。

---

初始化重载

Swift 初始化可以以与 函数重载 类似的方式重载。

在初始化程序重载中，如果两个或多个初始化程序具有不同类型或数量的参数，则它们可以具有相同的名称。

并且，根据对象创建期间传递的参数，调用相应的初始化构造函数。

让我们看一个例子，

class Person {
  var age: Int
  // 1. initializer with no arguments
  init() {
    age = 20
  }
  // 2. initializer with an argument
  init(age: Int) {
    self.age = age
  }
  // method to return age
  func getAge() -> Int {
    return age
  }
}
var person1 = Person()
var person2 = Person(age: 23)
print("Person1 Age:", person1.getAge())
print("Person1 Age:", person2.getAge())

结果如下:

Person1 Age: 20
Person1 Age: 23

在上面的实例中，我们创建了一个类 Person，它具有单个属性 age。

我们还定义了两个构造函数：init() 和 init(age:Int)。

我们没有向 person1 对象传递任何参数，因此调用了第一个构造函数。因此，age 被初始化为 20。

我们已经将 23 作为参数传递给 person2。因此，第二个构造函数被调用，age 被初始化为 23。

方法 getAge() 返回 age 的值，我们使用它来打印 person1 和 person2 的年龄。

---

Swift 便捷初始化

在前面的实例中，我们定义的初始化构造函数类的主初始值。这些主要初始化也称为指定初始化。

然而，我们也可以为一个名为便利初始化的类定义一个辅助/支持初始化的构造函数。

为了定义便捷初始化函数，我们在初始化之前使用关键字 convenience。例如，

class University {
  var name : String
  var rank : String
  init(name : String, rank: String) {
    self.name = name
    self.rank = rank
  }
  // define convenience init
  convenience init() {
    self.init(name: "Kathmandu University", rank: "1st")
  }
}
var university1 = University()
print(university1.name)
print("Rank:", university1.rank)

结果为:

Kathmandu University
Rank: 1st

在上面的实例中，我们创建了一个指定的初始化：init() 和一个便捷初始化：convenience init()。

在便捷初始化中，我们调用了指定的初始化函数并为属性赋值。

convenience init() {
  self.init(name: "Kathmandu University", rank: "1st")
}

创建 university1 对象时，将调用便捷初始化。

// using convenience initializer
var university1 = University()

与调用指定的初始化程序相比，这使我们的代码看起来更简洁：

// call designated initializer
var university1 = University(name: "Kathmandu University", rank: "1st")

---

失败的初始化

在某些情况下，初始化构造函数可能正常运行，也可能不运行，这称为失败的初始化。

我们通过放置一个问号(?)来编写一个失败的初始值设定项在 init 关键字之后，如果出现错误，则返回 nil。例如,

class File {
  var folder: String
  // failable initializer
  init?(folder: String) {
    // check if empty
    if folder.isEmpty {
      print("Folder Not Found") // 1st output
      return nil
    }
    self.folder = folder
  }
}
// create folder1 object
var file  = File(folder: "")
if (file != nil) {
  print("File Found Successfully")
}
else {
  print("Error Finding File") // 2nd output
}

结果如下:

Folder Not Found
Error Finding File

在上面的例子中，我们已经创建了失败的初始化程序 init?()，参数名为 folder。

并且，我们使用了 if 语句和 isEmpty 属性

if (folder.isEmpty) { return nil }

检查文件夹是否为空，如果为空则返回 nil。

对于 folder1 对象，我们传递了一个空字符串 ""，它会触发初始化失败，因此首先执行其中的语句，然后返回 nil。

最后，执行 else 块内的语句。

---

结构成员初始化

在 Swif t中，我们不需要在使用结构时创建初始值设定项。Swift 会自动为我们生成一个成员。例如，

struct Person {
  var name: String
  var age: Int
}

这里，我们没有在 Person 结构中创建任何初始值设定项。然而，Swift 会自动为我们生成一个成员初始化，

var person1 = Person(name: "Dwight", age: 43)

在这里，括号 () 内的值自动赋值给结构的相应属性。这称为成员初始化。

实例：成员初始化

struct Person {
  // define two properties
  var name: String
  var age: Int
}
// object of Person with memberwise initializer
var person1 = Person(name: "Dwight", age: 43)
print("Name:", person1.name)
print("Age:", person1.age)

结果为:

Name: Dwight
Age: 43

在上面的实例中，我们使用了自动生成的成员初始值来为 Person 结构的相应属性赋值。

var person1 = Person(name: "Dwight", age: 43)

这里，name 的值设置为 Dwight，age 设置为 43。