协议（Protocol）
- 协议可以用来定义
方法、属性、下标的声明，协议可以被枚举、结构体、类遵守（多个协议之间用逗号隔开）
protocol Test {
func fun()
var x: Int { get set }
var y: Int { get }
subscript(index: Int) -> Int {get set}
}
protocol Test1 {}
protocol Test2 {}
protocol Test3 {}
class TestClass: Test1, Test2, Test3 {}
- 协议中定义方法时不能有默认参数值
- 默认情况下，协议中定义的内容必须全部实现
协议中的属性
- 协议中定义属性时，必须用
var关键字 - 实现协议时，属性的权限不能小于协议中定义的属性权限
① 协议定义get、set，则用var存储属性或者get、set计算属性去实现
② 协议定义get，用任何属性都可以实现
eg:
protocol Drawable {
func draw()
var x: Int { get set }
var y: Int { get }
subscript(index: Int) -> Int { get set }
}
class Person: Drawable {
var x: Int = 0
var y: Int = 0
func draw() { print("Person draw") }
subscript(index: Int) -> Int {
get { index }
set {}
}
}
/*-----或者-----*/
class Person: Drawable {
var x: Int {
get { 0 }
set {}
}
var y: Int { 0 }
func draw() { print("Person draw") }
subscript(index: Int) -> Int {
get { index }
set {}
}
}
static、class
- 为了保证通用，协议中必须使用
static定义类型方法、类型属性、类型下标
因为class修饰的类型相关的事物，只能被类适用与类，结构体和枚举无法使用。
protocol Drawable {
static func draw()
}
class Person1: Drawable {
static func draw() {
print("Person1 draw")
}
}
struct Person2: Drawable {
static func draw() {
print("Person2 draw")
}
}
- 如果说，父类遵守了某个协议，子类想要去重写协议方法，那么在父类中，协议方法就要用
class来修饰，否则就要static来修饰。
protocol Drawable {
static func draw()
}
class Person1: Drawable {
class func draw() {
print("Person1 draw")
}
}
class Person2: Person1 {
override class func draw() {
print("Person2 draw")
}
}
mutating
- 只有将协议中的实例方法标记为
mutating，才允许结构体、枚举的具体实现修改自身内存。 -
类在不用加mutating，枚举、结构体才需要加mutating。
protocol Drawable {
mutating func draw()
}
class Person1: Drawable {
var x = 0
func draw() {
x += 1
}
}
struct Point: Drawable {
var x = 0
mutating func draw() {
x += 1
}
}
init
- 协议中还可以定义初始化器
init，非final类实现时必须加上required
因为final修饰的类，表明该类不能被继承，则不用担心子类不实现init的问题
protocol Drawable {
init(x: Int, y: Int)
}
class Person1: Drawable {
required init(x: Int, y: Int) {}
}
final class Person2: Drawable {
init(x: Int, y: Int) {}
}
- 如果从协议中实现的初始化器，刚好是重写了父类的指定初始化器，那么这个初始化必须同时加上
required、override
protocol Drawable {
init(x: Int, y: Int)
}
class Person {
init(x: Int, y: Int) {}
}
class Man: Person, Drawable {
required override init(x: Int, y: Int) {}
}
init、init?、init!
- 协议中定义的
init?、init!，可以用init、init?、init!去实现 - 协议中定义的
init，可以用init、init!去实现
protocol Drawable {
init()
init?(x: Int)
init!(y: Int)
}
class Person: Drawable {
required init() {}
// required init!() {}
required init?(x: Int) {}
// required init!(x: Int) {}
// required init(x: Int) {}
required init!(y: Int) {}
// required init?(y: Int) {}
// required init(y: Int) {}
}
协议的继承
- 一个协议可以继承其他协议
protocol Runnable {
func run()
}
protocol Livable: Runnable {
func breath()
}
class Person: Livable {
func breath() {}
func run() {}
}
协议的组合
- 协议组合的时候，可以包含1个
类类型（最多1个）
protocol Runnable {}
protocol Livable {}
class Person {}
// 接收Person 或 其子类的实例
func fn0(obj: Person) {}
// 接收遵守 Livable协议 的实例
func fn1(obj: Livable) {}
// 接收同时遵守 Livable、Runable协议 的实例
func fn2(obj: Livable & Runnable) {}
// 接收同时遵守 Livable、Runable协议，并且是 Person 或者 其子类的实例
func fn3(obj: Person & Livable & Runnable) {}
typealias RealPerson = Person & Livable & Runnable
// 接收同时遵守 Livable、Runable协议，并且是 Person 或者 其子类的实例
func fn4(obj: RealPerson) {}
CaseIterable
- 让枚举遵守
CasIterable协议，可以实现遍历枚举值
enum Season: CaseIterable {
case spring, summer, autumn, winter
}
let seasons = Season.allCases // [Season]
for season in seasons {
print(season)
}
/*输出结果*/
spring
summer
autumn
winter
我们可以看一下CaseIterable里面的内容
/// The compiler can automatically provide an implementation of the
/// `CaseIterable` requirements for any enumeration without associated values
/// or `@available` attributes on its cases. The synthesized `allCases`
/// collection provides the cases in order of their declaration.
///
/// You can take advantage of this compiler support when defining your own
/// custom enumeration by declaring conformance to `CaseIterable` in the
/// enumeration's original declaration. The `CompassDirection` example above
/// demonstrates this automatic implementation.
public protocol CaseIterable {
/// A type that can represent a collection of all values of this type.
associatedtype AllCases : Collection where Self == Self.AllCases.Element
/// A collection of all values of this type.
static var allCases: Self.AllCases { get }
}
可以看到allCases是一个可读的类型属性，通过官方给的注释，可以知道allCases是所有值的集合，那么在 当前情况下：
Season.allCases就等价于[Season.spring, Season.summer, Season.autumn, Season.winter]。
CustomStringConvertible
- 遵守
CustomStringConvertible、CustomDebugStringConvertible协议，都可以自定义实例的打印字符串
// 遵守 CustomStringConvertible & CustomDebugStringConvertible 协议
class Person: CustomStringConvertible, CustomDebugStringConvertible {
var age = 0
var description: String { "person_\(age)" }
var debugDescription: String { "debug_person_\(age)" }
}
var person = Person()
print(person)
debugPrint(person)
print("------------------------------------")
// 不遵守 CustomStringConvertible & CustomDebugStringConvertible 协议
class Man {
var age = 10
}
var man = Man()
print(man)
debugPrint(man)
/*输出结果*/
person_0
debug_person_0
------------------------------------
test.Man
test.Man
-
print调用的是CustomStringConvertible协议的description -
debugPrint、po调用的是CustomDebugStringConvertible协议的debugDescription
我们来看一下控制台的po：
image.png
Any、AnyObject
- Swift 提供了两种特殊的类型：
Any、AnyObject
①Any：可以代表任意类型（枚举、结构体、类，也包括函数类型）
②AnyObject：可以代表任意类类型（在协议后面写上：AnyObject代表只有类能遵守这个协议）。另外，在协议后面写上：class也代表只有类能遵守这个协议。
is、as?、as!、as
-
is用来判断是否为某种类型，as用来强制类型转换
protocol Runnable {
func run()
}
class Person {}
class Man: Person, Runnable {
func run() {
print("Man run")
}
func sleep() {
print("Man sleep")
}
}
我们先看一下is的使用
var m: Any = 10
print(m is Int) // true
m = "Tom"
print(m is String) // true
m = Man()
print(m is Person) // true
print(m is Man) // true
print(m is Runnable) // true
我们再来看一下as?、as!是如何用的
as? 表示转化可能成功，也可能失败。
as! 表示强制解包（注意：强制解包是有风险的）
var m: Any = 10
(m as? Man)?.sleep() // 没有调用sleep
m = Man()
(m as? Man)?.sleep() // Man sleep
(m as! Man).sleep() // Man sleep
(m as? Runnable)?.run() // Man run
那我们来看一下这一句代码
(m as? Man)?.sleep()
① 首先as? 表示转化可能成功，也可能失败。
② 紧接着第二个?是我们上一篇文章讲到的可选链的内容，如果前面的为nil后面的就不会执行。
我们再来看一下as
as 在可以转换成功的时候使用
var list = [Any]()
list.append(Int("123") as Any)
var num = 10 as Double
print(num) // 10.0
X.self、X.Type、AnyClass
-
X.self是一个元类型（metadata）的指针，metadata存放着类型相关的信息 -
X.self属于X.Type类型
这里大家要注意，实例对象在堆内存中存放的前8个字节就是类型信息。而且X.self就是8个字节，和实例对象在堆内存中存放的前8个字节是一样的。
下面我们来证明一下：
class Person {}
var p: Person = Person() // 注意：此处打上断点，进入汇编查看汇编代码
var pType: Person.Type = Person.self
首先我们来证明一下X.self是8个字节
image.png
结合Xcode注释和
movq指令可以断定X.self占8个字节（q代表8个字节，常用的汇编指令大家可以网上搜一下）
接下来我们再找一下
pType里面存放的内容是什么：
我们由下往上推论
image.png
那么我们可以在第12行处，打断点，看一下
%rax 里面存放的是什么
image.png
可以看到Xcode也给出了答案，此时
%rax里面存放的就是metadata信息。
那么接下来我们再看一下p里面存放的信息：
image.png
可以看到
p在堆内存里面的前8个字节的内容和pType一模一样。因此我们上面的推论是正确的。
下面我们看一下继承的关系
class Person {}
class Student: Person {}
var perType: Person.Type = Person.self
var stuType: Student.Type = Student.self
// 注意这样做是可以的，因为X.Type也是一个类型，并且Student继承自Person
// 从赋值角度看：perType 和 stuType 都是8个字节，也没什么问题
// 另外需要注意的是，这里如果把Student改成跟Person没有关系的其他类，比如Dog，就会报错，这样做是不允许的
perType = Student.self
var anyType: AnyObject.Type = Person.self
anyType = Student.self
public typealias AnyClass = AnyObject.Type
var anyType2: AnyClass = perType.self
anyType2 = Student.self
我们再看一个语法糖 type(of: <#T##T#>)
var per = Person()
var perType = type(of: per) // Person.self
print(Person.self == type(of: per)) // true
-
① 从汇编代码来看type(of: <#T##T#>)并不是一个函数调用，只是看起来像一个函数，这里大家可以通过汇编来查看一下，会发现其对应的并不是call指令。（大家可以自行查看一下）
image.png
② 通过Xcode的提示，type(of: <#T##T#>)又是一个函数，见下图：
image.png
具体原因，我暂时也不清楚，这里大家可以自行探索一下。之后弄明白了再给大家补上。
元类型的应用
- 比如开发中
tabbar的配置，就可以利用元类型来做。
class Animal {
required init() {}
}
class Cat: Animal {}
class Dog: Animal {}
class Pig: Animal {}
func create(_ clses: [Animal.Type]) -> [Animal] {
var arr = [Animal]()
for cls in clses {
arr.append(cls.init())
}
return arr
}
print(create([Cat.self, Dog.self, Pig.self])
下面我们来看一个小知识点
image.png
从打印结果，大家可以看到：
Person好像还有一个父类，但是根据Swift的文档，Swift的类并没有统一的基类，并且从代码看Person也没有继承自任何类。所以这里我们可以猜测，在Swift库里面应该还有一个隐藏的基类的。当然这个我们后续再验证，有兴趣的同学可以在Swift源码里面找一下。
Self
-
Self代表当前类型
class Person {
var age: Int = 0
static var count = 2
func fun() {
print(self.age) // 0
print(Self.count) // 2
}
}
-
Self一般用作返回值类型，限定返回值跟方法调用者必须是同一类型（也可以作为参数类型），类似于OC的instancetype
protocol Runnable {
func test() -> Self
}
class Person: Runnable {
func test() -> Self {
type(of: self).init()
}
required init() {}
}
class Student: Person {}
var p = Person()
print(p.test()) // Person
var s = Student() // Student
print(s.test())