Swift 进阶(九)协议、元类型
协议(Protocol)
基本概念
协议可以用来定义方法、属性、下标的声明,协议可以被结构体、类、枚举遵守
protocol Drawable {
func draw()
var x: Int { get set } // 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
,用任何属性都可以实现
protocol Drawable {
func draw()
var x: Int { get set }
var y: Int { get }
subscript(index: Int) -> Int { get set }
}
class Person1: Drawable {
var x: Int = 0
let y: Int = 0
func draw() {
print("Person1 draw")
}
subscript(index: Int) -> Int {
set { }
get { index }
}
}
class Person2: Drawable {
var x: Int {
get { 0 }
set { }
}
var y: Int { 0 }
func draw() {
print("Person2 draw")
}
subscript(index: Int) -> Int {
set { }
get { index }
}
}
class Person3: Drawable {
var x: Int {
get { 0 }
set { }
}
var y: Int {
get { 0 }
set { }
}
func draw() {
print("Person3 draw")
}
subscript(index: Int) -> Int {
set { }
get { index }
}
}
static、class
为了保证通用,协议中必须用static
定义类型方法、类型属性、类型下标
protocol Drawable {
static func draw()
}
class Person1: Drawable {
static func draw() {
print("Person1 draw")
}
}
class Person2: Drawable {
class func draw() {
print("Person2 draw")
}
}
mutating
只有将协议中的实例方法标记为mutating
,才允许结构体、枚举的具体实现修改自身内存
类在实现方法时不用加mutating
,结构体、枚举才需要加mutating
protocol Drawable {
mutating func draw()
}
class Size: Drawable {
var width: Int = 0
func draw() {
width = 10
}
}
struct Point: Drawable {
var x: Int = 0
mutating func draw() {
x = 10
}
}
init
协议中还可以定义初始化器init
,非final
类实现时必须加上required
目的是为了让所有遵守这个协议的类都拥有初始化器,所以加上required
强制子类必须实现,除非是加上final
不需要子类的类
protocol Drawable {
init(x: Int, y: Int)
}
class Point: Drawable {
required init(x: Int, y: Int) {
}
}
final class Size: Drawable {
init(x: Int, y: Int) {
}
}
如果从协议实现的初始化器,刚好是重写了父类的指定初始化器,那么这个初始化必须同时加上required、override
protocol Livable {
init(age: Int)
}
class Person {
init(age: Int) { }
}
class Student: Person, Livable {
required override init(age: Int) {
super.init(age: age)
}
}
协议中定义的init?、init!
,可以用init、init?、init!
去实现
protocol Livable {
init()
init?(age: Int)
init!(no: Int)
}
class Person1: Livable {
required init() {
}
required init?(age: Int) {
}
required init!(no: Int) {
}
}
class Person2: Livable {
required init() {
}
required init!(age: Int) {
}
required init?(no: Int) {
}
}
class Person3: Livable {
required init() {
}
required init(age: Int) {
}
required init(no: Int) {
}
}
协议中定义的init
,可以用init、init!
去实现
protocol Livable {
init()
init?(age: Int)
init!(no: Int)
}
class Person4: Livable {
required init!() {
}
required init?(age: Int) {
}
required init!(no: Int) {
}
}
协议的继承
一个协议可以继承其他协议
protocol Runnable {
func run()
}
protocol Livable: Runnable {
func breath()
}
class Person: Livable {
func breath() {
}
func run() {
}
}
协议组合
协议组合可以包含一个类类型
protocol Runnable { }
protocol Livable { }
class Person { }
// 接收Person或者其子类的实例
func fn0(obj: Person) { }
// 接收遵守Livable协议的实例
func fn1(obj: Livable) { }
// 接收同时遵守Livable、Runnable协议的实例
func fn2(obj: Livable & Runnable) { }
// 接收同时遵守Livable、Runnable协议,并且是Person或者其子类的实例
func fn3(obj: Person & Livable & Runnable) { }
typealias RealPerson = Person & Livable & Runnable
func fn4(obj: RealPerson) { }
CaseIterable
让枚举遵守CaseIterable
协议,可以实现遍历枚举值
enum Season: CaseIterable {
case spring, summer, autumn, winter
}
let seasons = Season.allCases
print(seasons.count)
for season in seasons {
print(season)
} // spring, summer, autumn, winter
CustomStringConvertible
遵守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) // person_0
debugPrint(person) // debug_person_0
print
调用的是CustomStringConvertible
协议的description
debugPrint、po
调用的是CustomDebugStringConvertible
协议的debugDescription
Any、AnyObject
Swift提供了两种特殊的类型Any、AnyObject
Any
可以代表任意类型(枚举、结构体、类,也包括函数类型)
var stu: Any = 10
stu = "Jack"
stu = Size()
var data = [Any]()
data.append(1)
data.append(3.14)
data.append(Size())
data.append("Jack")
data.append({ 10 })
AnyObject
可以代表任意类类型
在协议后面写上: AnyObject
,代表只有类能遵守这个协议
在协议后面写上: class
,也代表只有类能遵守这个协议
is、as
is
用来判断是否为某种类型
protocol Runnable {
func run()
}
class Person { }
class Student: Person, Runnable {
func run() {
print("Student run")
}
func study() {
print("Student study")
}
}
var stu: Any = 10
print(stu is Int) // true
stu = "Jack"
print(stu is String) // true
stu = Student()
print(stu is Person) // true
print(stu is Student) // true
print(stu is Runnable) // true
as
用来做强制类型转换
protocol Runnable {
func run()
}
class Person { }
class Student: Person, Runnable {
func run() {
print("Student run")
}
func study() {
print("Student study")
}
}
var stu: Any = 10
(stu as? Student)?.study() // 没有调用study
stu = Student()
(stu as? Student)?.study() // Student study
(stu as! Student).study() // Student study
(stu as? Runnable)?.run() // Student run
var data = [Any]()
data.append(Int("123") as Any)
var d = 10 as Double
print(d) // 10.0
元类型
X.self
X.self
是一个元类型的指针,metadata
存放着类型相关信息
X.self
属于X.Type
类型
class Person { }
class Student: Person { }
var perType: Person.Type = Person.self
var stuType: Student.Type = Student.self
perType = Student.self
var anyType: AnyObject.Type = Person.self
anyType = Student.self
var per = Person()
perType = type(of: per)
print(Person.self == type(of: per)) // true
AnyClass
的本质就是AnyObject.Type
var anyType2: AnyClass = Person.self
anyType2 = Student.self
元类型的应用
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]))
// a1、a2、a3、a4的写法等价
var a1 = Animal()
var t = Animal.self
var a2 = t.init()
var a3 = Animal.self.init()
var a4 = Animal.self()
Self
Self
代表当前类型
class Person {
var age = 1
static var count = 2
func run() {
print(self.age)
print(Self.count)
}
}
Self
一般用作返回值类型,限定返回值和方法调用者必须是同一类型(也可以作为参数类型)
protocol Runnable {
func test() -> Self
}
class Person: Runnable {
required init() {
}
func test() -> Self {
type(of: self).init()
}
}
class Student: Person {
}
var p = Person()
print(p.test()) // test_enum.Person
var stu = Student()
print(stu.test()) // test_enum.Student
元类型的本质
我们可以通过反汇编来查看元类型的实现是怎样的
var p = Person()
var pType = Person.self
我们发现最后存储到全局变量pType
中的地址值就是一开始调用的地址
再通过打印,我们发现pType
的值就是Person实例对象
的前8个字节的地址值,也就是类信息
我们再来看下面的示例代码
var p = Person()
var pType = type(of: p)
通过分析我们可以看到type(of: p)
本质不是函数调用,只是将Person实例对象
的前8个字节存储到pType
中,也证明了元类型的本质就是存储的类信息
我们还可以用以下方式来获取Swift的隐藏基类_TtCs12_SwiftObject
class Person {
var age: Int = 0
}
class Student: Person {
var no: Int = 0
}
print(class_getInstanceSize(Student.self)) // 32
print(class_getSuperclass(Student.self)!) // Person
print(class_getSuperclass(Student.self)!) // _TtCs12_SwiftObject
print(class_getSuperclass(NSObject.self)) // nil
我们可以查看Swift源码来分析该类型
发现SwiftObject
里面也有一个isa指针