Swift初始化器与可选链的使用方法介绍

初始化器

required

用required修饰指定初始化器，表明其所有子类都必须实现该初始化器（通过继承或者重写实现）

如果子类重写了required初始化器，也必须加上required，不用加上override

class Person {
  required init() {}
  init(age: Int) {}
}
class Student: Person {
  init(no: Int) {
      super.init(age: 0)
  }
  required init() {
      super.init()
  }
}

属性观察器

父类的属性在它自己的初始化器中赋值不会触发属性观察器，但在子类的初始化器中赋值会触发属性观察器

class Person {
  var age: Int {
      willSet {
          print("willSet", newValue)
      }
      didSet {
          print("didSet", oldValue, age)
      }
  }
  init() {
      self.age = 0
  }
}
class Student: Person {
  override init() {
      super.init()
      self.age = 1
  }
}

可失败初始化器

类、结构体、枚举都可以使用init?定义可失败初始化器

class Person {
  var name: String
  init?(name: String) {
      if name.isEmpty {
          return nil
      }
      self.name = name
  }
}

不允许同时定义参数标签、参数个数、参数类型相同的可失败初始化器和非可失败初始化器

可以用init!定义隐式解包的可失败初始化器

可失败初始化器可以调用非可失败初始化器，非可失败初始化器调用可失败初始化器需要进行解包

class Person {
  var name: String
  init?(name: String) {
      if name.isEmpty {
          return nil
      }
      self.name = name
  }
  convenience init() {
      self.init(name: "")!
  }
}

如果初始化器调用一个可失败初始化器导致初始化失败，那么整个初始化过程都失败，并且之后的代码都停止执行

可以用一个非可失败初始化器重写一个可失败初始化器，但反过来是不行的。

反初始化器（deinit）

deinit叫做反初始化器，类似于C++的析构函数、OC中的dealloc方法

当类的实例对象被释放内存时，就会调用实例对象的deinit方法

class Person {
  deinit {
      print("Person对象销毁了")
  }
}

deinit不接受任何参数，不能写小括号，不能自行调用

父类的deinit能被子类继承

子类的deinit实现执行完毕后会调用父类的deinit

可选链（Optional Chaining）

class Car {
  var price = 0
}
class Dog {
  var weight = 0
}
class Person {
  var name: String = ""
  var dog: Dog = Dog()
  var car: Car? = Car()
  func age() -> Int {
      18
  }
  func eat() {
      print("Person eat")
  }
  subscript(index: Int) -> Int {
      return index
  }
}
var person: Person? = Person()
var age = person?.age()//Int? Optional(18)
var age1 = person!.age() // Int
var name = person?.name //String?
var index = person?[6] // Int?

如果可选项为nil，调用方法、下标、属性失败，结果为nil

如果可选项不为nil，调用方法、下标、属性成功，结果会被包装成可选项

如果结果本来就是可选项，不会进行再次包装

判断方法有没有调用成功：

if let age = person?.age() { // ()?
  print("调用age成功", age)
} else {
  print("调用age失败")
}

形成可选链：

多个?可以链接在一起

如果链中任何一个节点是nil，那么整个链就会调用失败，可选链应用的地方还是很多的，在OC里面我们通常会加很多判断以避免崩溃，在Swift里面，因为有了可选链会减少很多我们自己的判断，提高了安全性。

var dog = person?.dog // Dog?
var weight = person?.dog.weight // Int?
var price = person?.car?.price // Int?

var scores = [
  "Jack" : [86, 82, 84],
  "Rose" : [79, 94, 81]
]
scores["Jack"]?[0] = 100
scores["Rose"]?[2] += 10
scores["Kate"]?[0] = 88

var num1: Int? = 5
num1? = 10 // Optional(10)
var num2: Int? = nil
num2? = 10 // nil

var dict: [String : (Int, Int) -> Int] = [
  "sum" : (+), //两个Int类型相加，返回一个Int类型
  "difference" : (-)
]
var result = dict["sum"]?(10, 20) // Optional(30), Int?

关于Swift初始化器与可选链的使用方法介绍的文章就介绍至此，更多相关Swift初始化器与可选链内容请搜索编程宝库以前的文章，希望以后支持编程宝库！

 初始化初始化器1、类、结构体、枚举都可以定义初始化器class Size { init(age: Int) { }}var s = Size(age: 10)2、类有2种初始化器：指定初始化器 ...