知不知

Swift笔记 - 07.单例模式、方法、下标、返回值、初始化

单例模式

public class FileManager {
    public static let shared = FileManager()
    private init() { }
}

public class FileManager {
    public static let shared = {
        // ...
        // ...
        return FileManager()
    }()
    private init() { }
}

方法(Method)

枚举、结构体、类都可以定义实例方法、类型方法
实例方法(InstanceMethod）：通过实例调用
类型方法(TypeMethod）：通过类型调用，用static或者class关键字定义

class Car {
    static var cout = 0
    init() {
        Car.cout += 1
    }
    static func getCount () -> Int { cout }
}
let c0 = Car()
let c1 = Car()
let c2 = Car()
print(Car.getCount ()) // 3

self
在实例方法中代表实例
在类型方法中代表类型
在类型方法staticfuncgetcount中
cout等价于self.cout.Car.self.cout.Car.cout

mutating关键字

结构体和枚举是值类型，默认情况下，值类型的属性不能被自身的实例方法修改
在func关键字前加mutating可以允许这种修改行为

struct Point {
    var x = 0.0, y = 0.0

    mutating func moveBy(deltaX: Double, deltaY: Double) {
        x += deltaX
        y += deltaY
        // self = Point(x: x + deltaX, y: y + deltaY)
    }
}

enum StateSwitch {
    case low, middle, high

    mutating func next() {
        switch self {
        case .low:
            self = .middle
        case .middle:
            self = .high
        case .high:
            self = .low
        }
    }
}

@discardableResult

在func前面加个gdiscardableResult，可以消除：函数调用后返回值末被使用的警告

struct Point {
    var x = 0.0, y = 0.0
    @discardableResult mutating
    func moveX(deltaX: Double) -> Double {
        x += deltaX
        return x
    }
}
var p = Point()
p.moveX(deltaX: 10)

@discardableResult
func get() -> Int {
    return 10
}
get()

下标 (subscript)

使用subscript可以给任意类型（枚举、结构体、类）增加下标功能，有些地方也翻译为：下标脚本
subscript的语法类似于实例方法、计算属性，本质就是方法（函数）

class Point {
    var x = 0.0, y = 0.0
    subscript(index: Int) -> Double {
        set {
            if index == 0 {
                x = newValue
            } else if index == 1 {
                y = newValue
            }
        }
        get {
            if index == 0 {
                return x
            } else if index == 14 {
                return y
            }
            return 0
        }
    }
}

var p = Point()
p[0] = 11.1
p[1] = 22.2
print(p.x) // 11.1
print(p.y) // 22.2
print(p[0]) // 11.1
print(p[1]) // 22.2

subscript中定义的返回值类型決定了
get方法的返回值类型
set方法中newValue的类型
subscript可以接受多个参数，并且类型任意
subscript可以没有set方法，但必须要有get方法

class Point {
    var x = 0.0, y = 0.0
    subscript(index: Int) -> Double {
        get {
            if index == 0 {
                return x
            } else if index == 1 {
                return y
            }
            return 0
        }
    }
}

如果只有get方法，可以省略get

class Point {
    var x = 0.0, y = 0.0
    subscript(index: Int) -> Double {
        if index == 0 {
            return x
        } else if index == 1 {
            return y
        }
        return 0
    }
}

可以设置参数标签

class Point {
    var x = 0.0, y = 0.0
    subscript(index i: Int) -> Double {
        if i == 0 {
            return x
        } else if i == 1 {
            return y
        }
        return 0
    }
}

var p = Point()
p.y = 22.2
print(p[index: 1]) // 22.2

下标可以是类型方法

class Sum {
    static subscript(v1: Int, v2: Int) -> Int {
        return v1 + v2
    }
}
print(Sum[10, 20])

结构体、类作为返回值对比

class Point {
    var x = 0, y = 0
}

class PointManager {
    var point = Point()
    subscript(index: Int) -> Point {
        get {
            point
        }
    }
}

var pm = PointManager()
pm[0].x = 11
pm[0].y = 22
// Point (x: 11, y: 22)
print(pm[0])
// Point (x: 11, y: 22)
print(pm.point)

struct Point {
    var x = 0, y = 0

    class PointManager {
        var point = Point()
        subscript(index: Int) -> Point {
            set {
                point = newValue
            }
            get {
                point
            }
        }
    }
}

接收多个参数的下标

class Grid {
    var data = [
        [0, 1, 21],
        [3, 4, 5],
        [6, 7, 8]
    ]
    subscript(row: Int, column: Int) -> Int {
        set {
            guard row >= 0 && row < 3 && column >= 0 && column < 3 else {
                return
            }
            data[row][column] = newValue
        }
        get {
            guard row >= 0 && row < 3 && column >= 0 && column < 3 else {
                return 0
            }
            return data[row][column]
        }
    }
}

var grid = Grid()
grid[0, 1] = 77
grid[1, 2] = 88
grid[2, 0] = 99
print(grid.data)

继承

值类型（枚举、结构体）不支持继承，只有类支持继承
没有父类的类，称为：基类
Swift并没有像OC、Java那样的规定：任何类最终都要继承自某个基类
子类可以重写父类的下标、方法、属性，重写必须加上override关键字

重写实例方法、下标

class Animal {
    func speak() {
        print ("Animal speak")
    }
    subscript (index: Int) -> Int {
        return index
    }
}

var anim: Animal
anim = Animal()
// Animal speak
anim.speak()
// 6
print(anim[6])

class Cat: Animal {
    override func speak() {
        super.speak()
        print ("Cat speak")
    }
    override subscript (index: Int) -> Int {
        return super [index] + 1
    }
}

anim = Cat()
// Animal speak
// Cat speak
anim. speak() // 7
print(anim[6))

被class修饰的类型方法、下标，允许被子类重写
被static修饰的类型方法、下标，不允许被子类重写

class Animal {
    class func speak() {
        print ("Animal speak")
    }
    class subscript(index: Int) -> Int {
        return index
    }
}
// Animal speak
Animal.speak()
// 6
print(Animal[6])

class Cat : Animal {
    override class func speak() {
        super.speak()
        print ("Cat speak")
    }
    override class subscript (index: Int) -> Int {
        return super[index] + 1
    }
}
// Animal speak
// Cat speak
Cat.speak() // 7
print (Cat [6])

重写属性

子类可以特父类的属性（存储、计算）重号为计算属性
子类不可以将父类重写为存储属性
只能重写var属性，不能重写let属性
重与时，属性名、类型要一致
子类重写后的属性权限不能小于父类属性的权限
如果父类属性是只读的，那么子类重写后的属性可以是只读的、也可以是可读写的。
如果父类属性是可读写的，那么子类重写后的属性也必须是可读写的
被class修饰的计算类型属性，可以被子类重写
被static修饰的类型属性（存储、计算），不可以被子类重写

class Circle {
    static var radius: Int = 0
    class var diameter: Int {
        set {
            print("Circle setDianeter")
            radius = newValue / 2
        }
        get {
            print("Circle getDianeter")
            return radius * 2
        }
    }
}

class SubCircle: Circle {
    override static var diameter: Int {
        set {
            print("SubCircle setDianeter")
            super.diameter = newValue > 0 ? newValue : 0
        }
        get {
            print("SubCircle getDianeter")
            return super.diameter
        }
    }
}

Circle.radius = 6
// Circle getDianeter
// 12
print(Circle.diameter)
// Circle setDianeter
Circle.diameter = 28
// 10
print(Circle.radius)

SubCircle.radius = 6
// SubCircle getDianeter
// Circle getDianeter
// 12
print(Circle.diameter)
// SubCircle setDianeter
// Circle setDiameter
SubCircle.diameter = 20
// 10
print(SubCircle.radius)

属性观察器

可以在子类中为父类属性（除了只读计算属性、let属性）增加属性观察器

class Circle {
    var radius: Int = 1
}

class SubCircle: Circle {
    override var radius: Int {
        willSet {
            print("SubCircle willSetRadius", newValue)
        }
        didSet {
            print("SubCircle didSetRadius", oldValue, radius)
        }
    }
}

var circle = SubCircle()
// SubCircle willSetRadius 10
// SubCircle didSetRadius 1 10
circle.radius = 10

子类给父类的计算属性添加属性观察器

class Circle {
    var radius: Int {
        set {
            print("Circle setRadius", newValue)
        }
        get {
            print("Circle getRadius")
            return 20
        }
    }
}

class SubCircle: Circle {
    override var radius: Int {
        willSet {
            print("SubCircle willetRadius", newValue)
        }
        didSet {
            print("SubCircle didSetRadius", oldValue, radius)
        }
    }
}

var circle = SubCircle()
// Circle getRadius
// SubCircle willSetRadius 10
// Circle setRadius 10
// Circle getRadius
// SubCircle didSetRadius 20 20
circle.radius = 10

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

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

class Student: Person {
    override init() {
        super.init()
        self.age = 1
    }
}

// willSet 1
// didSet 0 1
var stu = Student()

final

被final修饰的方法、下标、属性，禁止被重写
被final修饰的类，禁止被继承

初始化器

类、结构体、枚举都可以定义初始化器
类有2种初始化器：指定初始化器（designated initializer）、便捷初始化器(convenience initializer)

//指定初始化器
init(parameters) {
    statements
}

//便捷初始化器
convenience init(parameters) {
    statements
}

每个类至少有一个指定初始化器，指定初始化器是类的主要初始化器
默认初始化器总是类的指定初始化器
类偏向于少量指定初始化器，一个类通常只有一个指定初始化器
初始化器的相互调用规则
- 指定初始化器必须从它的直系父类调用指定初始化器
- 便捷初始化器必须从相同的类里调用另一个初始化器
- 便捷初始化器最终必须调用一个指定初始化器

初始化器的相互调用

指定初始化器是纵向调用的；便捷初始化器是横向调用的。

两段式初始化

Swift在编码安全方面是煞费苦心，为了保证初始化过程的安全，设定了两段式初始化、安全检查
两段式初始化
- 第1阶段：初始化所有存储属性
  1. 外层调用指定便捷初始化器
  2. 分配内存给实例，但末初始化
  3. 指定初始化器确保当前类定义的存储属性都初始化
  4. 指定初始化器调用父类的初始化器，不断向上调用，形成初始化器链
- 第2阶段：设置新的存储属性值
  1. 从顶部初始化器往下，链中的每-
  2. 个指定初始化器都有机会进一步定制实例
  3. 初始化器现在能够使用self（访问、修改它的属性，调用它的实例方法等等）
  4. 最终，链中任何便捷初始化器都有机会定制实例以及使用self

安全检查

指定初始化器必须保证在调用父类初始化器之前，其所在类定义的所有存储属性都要初始化完成
指定初始化器必须先调用父类初始化器，然后才能为继承的属性设置新值
便捷初始化器必须先调用同类中的其它初始化器，然后再为任意属性设置新值
初始化器在第1阶段初始化完成之前，不能调用任何实例方法、不能读取任何实例属性的值，也不能引用self
直到第1阶段结束，实例才算完全合法
当重写父类的指定初始化器时，必须加上override（即使子类的实现是便捷初始化器）
如果子类写了一个匹配父类便捷初始化器的初始化器，不用加上override
- 因为父类的便捷初始化器永远不会通过子类直接调用，因此，严格来说，子类无法重写父类的便捷初始化器

自动继承

如果子类没有自定义任何指定初始化器，它会自动继承父类所有的指定初始化器
如果子类提供了父类所有指定初始化器的实现（要么通过方式1继承，要么重写）
- 子类自动继承所有的父类便捷初始化器
就算子类添加了更多的便捷初始化器，这些规则仍然适用
子类以便捷初始化器的形式重写父类的指定初始化器，也可以作为满足规则2的一部分

required 关键字

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

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

可失败初始化器

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

class Person {
    var name: String

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

之前接触过的可失败初始化器

var num = Int("123")
public init?(_ description: String)

enum Answer : Int {
    case wrong, right
}
var an = Answer(rawValue: 1)

不允许同时定义参数标签、参数个数、参数类型相同的可失败初始化器和非可失败初始化器
可以用init!定义隐式解包的可失败初始化器
可失败初始化器可以调用非
失败初始化器，非可失败初始化器调用可失败初始化器需要进行解包
如果初始化器调用一个可失败初始化器导致初始化失败，那么整个初始化过程都失败，并且之后的代码都停止执行
可以用一个非可失败初始化器重写一个可失败初始化器，但反过来是不行的

反初始化器

deinit叫做反初始化器，类似于C++的析构西数、OC中的dealloc方法
当类的实例对象被释放内存时，就会调用实例对象的deinit方法

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

deinit不接受任何参数，不能写小括号，不能自行调用
父类的deinit能被子类继承
子类的deinit实现执行完毕后会调用父类的deinit

知不知

知不知 是一个代码爱好者的技术知识分享部落格。

Swift笔记 - 07.单例模式、方法、下标、返回值、初始化

Swift笔记 - 07.单例模式、方法、下标、返回值、初始化

单例模式

方法(Method)

mutating关键字

下标 (subscript)

结构体、类作为返回值对比

继承

重写实例方法、下标

重写属性

属性观察器

初始化器

两段式初始化

知不知是一个代码爱好者的技术知识分享部落格。