10. Swift 类 Class.png

创建类

class Person {
    var name: String = ""
    var age: Int?
    var id: String?
    init(name: String) {
        self.name = name
    }
    func introduce() {
        print("Person (name: \(name))")
    }
}
let p = Person(name: "huangjian")
p.introduce()

恒等运算符

Swift 中除了 class 类型是引用类型，其他整型，浮点型，数组，结构体等都是值类型。
值类型的每个实例没有独一无二的标识，而引用类型的每个实例都有独一无二的标识。

=== 只能用于判断两个类的实例是不是同一个实例，即判断内存地址是否一致。
== 可以用于任何数据类型的判断，包括值类型和引用类型。
如果要使用 == ，都需遵循 Equatable 协议，并实现 == 静态方法，以此来判断两实例是否等同。

extension Person: Equatable {
    static func == (lhs: Person, rhs: Person) -> Bool {
        return lhs.id == rhs.id
    }
}
let p1 = Person(name: "huangjian")
p1.age = 28
p1.id = "10001"
let p2 = Person(name: "jack")
p2.age = 56
p2.id = "10001"
print(p1 == p2) // true  因为两个对象的属性 id 相等，所以他们是同一个人

备注：[参考]

构造器

构造过程是为了使用某个类、结构体或枚举类型的实例而进行的准备过程。
这个过程包含了为实例中的每个属性设置初始值和为其执行必要的准备和初始化任务。

Swift 默认构造函数使用 init() 方法，与 Objective-C 中的构造器不同，
Swift 的构造器无需返回值，它们的主要任务是保证新实例在第一次使用前完成正确的初始化。

类实例也可以通过定义析构器（deinitializer）在类实例释放之前执行清理内存的工作。

存储型属性的初始赋值

类和结构体在实例创建时，必须为所有存储型属性设置合适的初始值。
存储属性在构造器中赋值时，它们的值是被直接设置的，不会触发任何属性观测器。

存储属性在构造器中赋值流程：

创建初始值。
在属性定义中指定默认属性值。
初始化实例，并调用 init() 方法。

指定构造器和便利构造器

类构造器分为指定构造器和便利构造器

一个指定构造器必须调用它直系父类的一个指定构造器。
一个便利构造器必须调用这个类自身的另一个构造器。
一个便利构造器最终一定会调用一个指定构造器。

总的来说就是，便利构造器是为你类的初始化工作提供方便的，
它们最终一定要依赖于那些真正使你类能正常工作的初始化工作，这也就是指定构造器的工作。

class MainClass {
    var prop: Int
    init(prop: Int) {
        self.prop = prop
    }
}
class SubClass: MainClass {
    var prop2: Int
    init(prop: Int, prop2: Int) {
        self.prop2 = prop2
        super.init(prop: prop)
    }
}

便利构造器：

init 之前有关键字 convenience
少量参数
通过调用自身的其他初始化方法 self.init，并给某些参数设置默认值

class MainClass {
    var prop: Int
    init(prop: Int) {
        self.prop = prop
    }
}
class SubClass: MainClass {
    var prop2: Int
    init(prop: Int, prop2: Int) {
        self.prop2 = prop2
        super.init(prop: prop)
    }
    override convenience init(prop: Int) {
        self.init(prop: prop, prop2: 0)
    }
}

可失败构造器

如果一个类，结构体或枚举类型的对象，在构造自身的过程中有可能失败，则为其定义一个可失败构造器。

变量初始化失败可能的原因有：

传入无效的参数值。
缺少某种所需的外部资源。
没有满足特定条件。

为了妥善处理这种构造过程中可能会失败的情况。你可以在一个类，结构体或是枚举类型的定义中，添加一个或多个可失败构造器。其语法为在 init 关键字后面加添问号 init?

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

析构

在一个类的实例被释放之前，析构函数被立即调用。
用关键字 deinit 来标示析构函数，类似于初始化函数用 init 来标示。

Swift 会自动释放不再需要的实例以释放资源，通过自动引用计数（ARC）处理实例的内存管理。

通常当你的实例被释放时不需要手动地去清理。但是，当使用自己的资源时，你可能需要进行一些额外的清理。
例如，如果创建了一个自定义的类来打开一个文件，并写入一些数据，你可能需要在类实例被释放之前关闭该文件。
再如，在析构函数中移除监听、移除通知、销毁对象、销毁定时器等。

在类的定义中，每个类最多只能有一个析构函数。析构函数不带任何参数，在写法上不带括号

class MyClass {
    init() {
        print("MyClass.init...")
    }
    deinit {
        print("MyClass.deinit...")
    }
}
var my: MyClass? = MyClass()
my = nil

属性

Swift 属性可分为存储属性和计算属性，let 修饰的常量只能是普通的存储属性！

存储属性

存储属性就是存储在类的实例里的一个常量或变量

延迟存储属性

延迟存储属性是指当第一次被调用的时候才会计算其初始值的属性，且仅会计算一次，在属性声明前使用 lazy 来标示一个延迟存储属性。

注意：
必须将延迟存储属性声明成变量（使用 var 关键字），因为属性的值在实例构造完成之前可能无法得到。
而常量属性在构造过程完成之前必须要有初始值，因此无法声明成延迟属性。

延迟存储属性一般用于：

延迟对象的创建
当属性的值依赖于其他未知类

格式：

lazy var Property: Type = Value

lazy var Property: Type = xxxMethod(...)

lazy var Property: Type = { 
    Code 
}()

例子：

class MyClass {
    lazy var other = OtherClass()
    init() {
        print("MyClass.init...")
    }
}
class OtherClass {
    var name = "Swift"
    init() {
        print("OtherClass.init...")
    }
}
var my = MyClass()
print(my.other.name)

计算属性

计算属性不直接存储值，而是提供一个 getter 来获取值，一个可选的 setter 来间接设置其他属性或变量的值。
计算属性的赋值是赋值给其他变量，计算属性的获取是通过其他变量来获取的，更不能赋初始值。
必须使用 var 关键字定义计算属性，包括只读计算属性，因为它们的值不是固定的。

class Person {
    var firstName: String = ""
    var lastName: String = ""
    var fullName: String {
        set {
            /**
             可以通过默认提供的 `newValue` 来获取新值，
             或者通过自定义参数 `set(value)` 来获取新值，二选一
             */
            let array: [Substring] = newValue.split(separator: " ")
            if array.count == 2 {
                firstName = String(array.first!)
                lastName = String(array.last!)
            }
        }
        get {
            return "\(firstName) \(lastName)"
        }
    }
}
do {
    let p = Person()
    p.fullName = "Steve Jobs"
    print(p.firstName)
    print(p.lastName)
}
do {
    let p = Person()
    p.firstName = "Steve"
    p.lastName = "Jobs"
    print(p.fullName)
}

只读计算属性

如果计算属性只有 get 而没有 set，则该计算属性为只读计算属性。
只读计算属性的 getter 方法可以隐藏，将方法体置于外层。

静态属性

也称类属性，类型属性，作用于类而非类的实例。与实例属性语法相同，在属性定义前添加 static 关键字修饰即可

class Person {
    static let maxAge = 200
}
print(Person.maxAge)

属性观察器

只能用于普通的存储属性，而且是可变属性 (变量 var)

属性观察器监控和响应属性值的变化，每次属性被设置值的时候都会调用属性观察器，甚至新的值和现在的值相同的时候也不例外。不需要为无法重载的计算属性添加属性观察器，因为可以通过 setter 直接监控和响应值的变化。

可以为除了延迟存储属性之外的其他存储属性添加属性观察器，也可以通过重载属性的方式为继承的属性（包括存储属性和计算属性）添加属性观察器。

可以为属性添加如下的一个或全部观察器：

willSet 在设置新的值之前调用
didSet 在新的值被设置之后立即调用
willSet 和 didSet 观察器在属性初始化过程中不会被调用

class Clock {
    var counter: Int = 0 {
        willSet {
            /**
             可以通过默认提供的 `newValue` 来获取新值，
             或者通过自定义参数 `willSet(value)` 来获取新值，二选一
             */
            print("[willSet] newValue: \(newValue), oldValue: \(self.counter)")
        }
        didSet {
            /**
             可以通过默认提供的 `oldValue` 来获取旧值，
             或者通过自定义参数 `didSet(value)` 来获取旧值，二选一
             */
            print("[didSet] oldValue: \(oldValue), newValue: \(self.counter)")
        }
    }
}
let cc = Clock()
cc.counter = 3
/**
 [willSet] newValue: 3, oldValue: 0
 [didSet] oldValue: 0, newValue: 3
 */

备注：计算属性和属性观察器所描述的模式也可以用于全局变量和局部变量。

下标脚本

举例来说，用下标脚本访问一个数组 (Array) 实例中的元素可以这样写 someArray[index] ，访问字典 (Dictionary) 实例中的元素可以这样写 someDictionary[key]。

下标脚本可以认为是访问对象、集合或序列的快捷方式，不需要再调用实例的特定的赋值和访问方法。

下标脚本允许你通过在实例后面的方括号中传入一个或者多个的索引值来对实例进行访问和赋值。同样可以根据自身需要提供多个下标脚本实现。下标脚本的方法为 subscript，方法的参数和返回值可以完全自定义。

class MyClass {
    var array: Array<String> = []
    subscript(index: Int) -> String? {
        set {
            if index <= array.count && newValue != nil {
                array.insert(newValue!, at: index)
            } else {
                print(index, array.count)
            }
        }
        get {
            if index >= array.count {
                return nil
            }
            return array[index]
        }
    }
}
let my = MyClass()
my[0] = "apple"
my[1] = "orange"
my[2] = "banana"
my[4] = nil
print(my.array)

继承

Swift 不支持多继承，子类可重写（访问）父类的属性、方法、下标脚本、属性观察器。
如果父类的属性、方法等不可以被子类重写，可在其前面添加 final 关键字。

class Animal {
    var name: String = ""
    init(name: String) {
        self.name = name
    }
    func run() {
        print("Animal(name: \(name)) is running")
    }
}
class Dog: Animal {
    /**
     通过 `set` 和 `get` 来重写父类的 `name` 属性，
     只能是可变属性，即变量，包括存储型属性和计算型属性
     */
    override var name: String {
        set {
            print("Dog.name set ...")
            super.name = newValue
        }
        get {
            print("Dog.name get ...")
            return super.name
        }
    }
    override init(name: String) {
        super.init(name: name)
    }
    // 重写父类的 `run` 方法
    override func run() {
        print("Dog(name: \(super.name)) is running")
    }
}
let dog = Dog(name: "wangcai")
dog.name = "doudou"
dog.run()

扩展

扩展可以对一个类型添加新的功能，但是不能重写已有的功能。

Swift 中的扩展可以：

添加计算型属性和计算型静态属性
定义实例方法和类型方法
提供新的构造器
定义下标
定义和使用新的嵌套类型
使一个已有类型符合某个协议

class Person {
    var firstName: String = ""
    var lastName: String = ""
}
extension Person {
    var fullName: String {
        set {
            let array = newValue.split(separator: " ")
            if array.count == 2 {
                firstName = String(array.first!)
                lastName = String(array.last!)
            }
        }
        get {
            return "\(firstName) \(lastName)"
        }
    }
    func description() -> String {
        return "Person (fullName: \(fullName))"
    }
}
let p = Person()
p.firstName = "Steve"
p.lastName = "Jobs"
print(p.description())

协议

类可以遵循协议，并提供具体实现来完成协议定义的方法和功能。

协议对属性的规定

协议用于指定特定的实例属性或类属性，而不用指定是存储型属性或计算型属性。此外还必须指明是只读的还是可读可写的。
协议中的通常用var来声明变量属性，在类型声明后加上{ set get }来表示属性是可读可写的，只读属性则用{ get }来表示。

协议对构造器的规定：遵循并实现某协议的构造方法，需要在构造方法最前面添加 required 修饰符。

协议可继承。

protocol MyProtocol1 {
    var prop1: Int { set get }
    var prop2: String { get }
    func method1()
    func method2(_: String)
}
protocol MyProtocol2 {
    init(name: String)
    func method(name: String) -> String
}
class MyClass: MyProtocol1, MyProtocol2 {
    // MARK: - MyProtocol1
    var prop1: Int = 0
    var prop2: String {
        get {
            return ""
        }
    }
    func method1() {
    }
    func method2(_ name: String) {
    }
    // MARK: - MyProtocol2
    // 如果遵循协议，需要加上 `required`；如果继承自父类，需要加上 `override`
    required init(name: String) {
    }
    func method(name: String) -> String {
        return ""
    }
}

你可以在协议的继承列表中，通过添加 class 关键字，限制协议只能适配到类（class）类型。该 class 关键字必须是第一个出现在协议的继承列表中，其后，才是其他继承协议。

protocol MyProtocol: class, Equatable {
}

其他限定：where 语句可以用来设置约束条件、限制类型

import UIKit
protocol MyProtocol where Self: UITableViewController {
}

检验协议的一致性：
你可以使用 is 和 as 操作符来检查是否遵循某一协议或强制转化为某一类型。

is 操作符用来检查实例是否遵循了某个协议。
as? 返回一个可选值，当实例遵循协议时，返回该协议类型，否则返回 nil。
as 用以强制向下转型，如果强转失败，会引起运行时错误。

访问控制

五种访问控制修饰符 open、public、internal、fileprivate、private

官方：https://docs.swift.org/swift-book/LanguageGuide/AccessControl.html
翻译：https://learnku.com/docs/the-swift-programming-language/4.2/AccessControl/3546
参考：https://www.jianshu.com/p/97cc7b693a60