Swift 初始化器

初始化器是一种特殊的函数，用于创建类或结构的实例。

在 Swift 中，我们使用 init() 方法来创建初始化器。例如，

class Wall {
  ...

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

在这里，init() 方法是 Wall 类的初始化器。

示例：Swift 初始化器

// 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) - 带参数 length 的初始化器
• 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)。

1. 我们没有向 person1 对象传递任何参数，因此调用了第一个初始化器。因此，age 被初始化为 20。
2. 我们将 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

在上面的示例中，我们创建了一个名为 folder 的参数的可失败初始化器 init?()。

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

if (folder.isEmpty) { return nil }

来检查 folder 是否为空，如果为空则返回 nil。

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

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

结构体的成员初始化器

在 Swift 中，我们在处理结构体时不需要创建初始化器。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。