Swift笔记 - 07.单例模式、方法、下标、返回值、初始化
Swift笔记 - 07.单例模式、方法、下标、返回值、初始化
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阶段：初始化所有存储属性
- 外层调用指定便捷初始化器
- 分配内存给实例，但末初始化
- 指定初始化器确保当前类定义的存储属性都初始化
- 指定初始化器调用父类的初始化器，不断向上调用，形成初始化器链
第2阶段：设置新的存储属性值
- 从顶部初始化器往下，链中的每-
- 个指定初始化器都有机会进一步定制实例
- 初始化器现在能够使用
self（访问、修改它的属性，调用它的实例方法等等） - 最终，链中任何便捷初始化器都有机会定制实例以及使用
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