经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 移动开发 » iOS » 查看文章
Swift 进阶（九）协议、元类型
来源：cnblogs　　作者：FunkyRay　　时间：2021/4/12 9:50:56　　对本文有异议

协议（Protocol）

基本概念

协议可以用来定义方法、属性、下标的声明，协议可以被结构体、类、枚举遵守

  1. protocol Drawable {
  2.     func draw()
  3.     var x: Int { get set } // get和set只是声明
  4.     var y: Int { get }
  5.     subscript(index: Int) -> Int { get set }
  6. }

多个协议之间用逗号隔开

  1. protocol Test1 { }
  2. protocol Test2 { }
  3. protocol Test3 { }
  5. class TestClass: Test1, Test2, Test3 { }

协议中定义方法时不能有默认参数值

-w633

默认情况下，协议中定义的内容必须全部都实现

协议中的属性

协议中定义属性必须用var关键字

实现协议时的属性权限要不小于协议中定义的属性权限

  • 协议定义get、set，用var存储属性或get、set计算属性去实现
  • 协议定义get，用任何属性都可以实现
  1. protocol Drawable {
  2.     func draw()
  3.     var x: Int { get set }
  4.     var y: Int { get }
  5.     subscript(index: Int) -> Int { get set }
  6. }
  8. class Person1: Drawable {
  9.     var x: Int = 0
  10.     let y: Int = 0
  11.     
  12.     func draw() {
  13.         print("Person1 draw")
  14.     }
  15.     
  16.     subscript(index: Int) -> Int {
  17.         set { }
  18.         get { index }
  19.     }
  20. }
  22. class Person2: Drawable {
  23.     var x: Int {
  24.         get { 0 }
  25.         set { }
  26.     }
  27.     
  28.     var y: Int { 0 }
  29.     
  30.     func draw() {
  31.         print("Person2 draw")
  32.     }
  33.     
  34.     subscript(index: Int) -> Int {
  35.         set { }
  36.         get { index }
  37.     }
  38. }
  40. class Person3: Drawable {
  41.     var x: Int {
  42.         get { 0 }
  43.         set { }
  44.     }
  45.     
  46.     var y: Int {
  47.         get { 0 }
  48.         set { }
  49.     }
  50.     
  51.     func draw() {
  52.         print("Person3 draw")
  53.     }
  54.     
  55.     subscript(index: Int) -> Int {
  56.         set { }
  57.         get { index }
  58.     }
  59. }

static、class

为了保证通用，协议中必须用static定义类型方法、类型属性、类型下标

  1. protocol Drawable {
  2.     static func draw()
  3. }
  5. class Person1: Drawable {
  6.     static func draw() {
  7.         print("Person1 draw")
  8.     }
  9. }
  11. class Person2: Drawable {
  12.     class func draw() {
  13.         print("Person2 draw")
  14.     }
  15. }

mutating

只有将协议中的实例方法标记为mutating，才允许结构体、枚举的具体实现修改自身内存

类在实现方法时不用加mutating，结构体、枚举才需要加mutating

  1. protocol Drawable {
  2.     mutating func draw()
  3. }
  5. class Size: Drawable {
  6.     var width: Int = 0
  7.     
  8.     func draw() {
  9.         width = 10
  10.     }
  11. }
  13. struct Point: Drawable {
  14.     var x: Int = 0
  15.     mutating func draw() {
  16.         x = 10
  17.     }
  18. }

init

协议中还可以定义初始化器init，非final类实现时必须加上required

目的是为了让所有遵守这个协议的类都拥有初始化器，所以加上required强制子类必须实现，除非是加上final不需要子类的类

  1. protocol Drawable {
  2.     init(x: Int, y: Int)
  3. }
  5. class Point: Drawable {
  6.     required init(x: Int, y: Int) {
  7.         
  8.     }
  9. }
  11. final class Size: Drawable {
  12.     init(x: Int, y: Int) {
  13.         
  14.     }
  15. }

如果从协议实现的初始化器，刚好是重写了父类的指定初始化器，那么这个初始化必须同时加上required、override

  1. protocol Livable {
  2.     init(age: Int)
  3. }
  5. class Person {
  6.     init(age: Int) { }
  7. }
  9. class Student: Person, Livable {
  10.     required override init(age: Int) {
  11.         super.init(age: age)
  12.     }
  13. }

协议中定义的init?、init!，可以用init、init?、init!去实现

  1. protocol Livable {
  2.     init()
  3.     init?(age: Int)
  4.     init!(no: Int)
  5. }
  7. class Person1: Livable {
  8.     required init() {
  9.         
  10.     }
  11.     
  12.     required init?(age: Int) {
  13.         
  14.     }
  15.     
  16.     required init!(no: Int) {
  17.         
  18.     }
  19. }
  21. class Person2: Livable {
  22.     required init() {
  23.         
  24.     }
  25.     
  26.     required init!(age: Int) {
  27.         
  28.     }
  29.     
  30.     required init?(no: Int) {
  31.         
  32.     }
  33. }
  35. class Person3: Livable {
  36.     required init() {
  37.         
  38.     }
  39.     
  40.     required init(age: Int) {
  41.         
  42.     }
  43.     
  44.     required init(no: Int) {
  45.         
  46.     }
  47. }

协议中定义的init，可以用init、init!去实现

  1. protocol Livable {
  2.     init()
  3.     init?(age: Int)
  4.     init!(no: Int)
  5. }
  7. class Person4: Livable {
  8.     required init!() {
  9.         
  10.     }
  11.     
  12.     required init?(age: Int) {
  13.         
  14.     }
  15.     
  16.     required init!(no: Int) {
  17.         
  18.     }
  19. }

协议的继承

一个协议可以继承其他协议

  1. protocol Runnable {
  2.     func run()
  3. }
  5. protocol Livable: Runnable {
  6.     func breath()
  7. }
  9. class Person: Livable {
  10.     func breath() {
  11.         
  12.     }
  13.     
  14.     func run() {
  15.         
  16.     }
  17. }

协议组合

协议组合可以包含一个类类型

  1. protocol Runnable { }
  2. protocol Livable { }
  3. class Person { }
  5. // 接收Person或者其子类的实例
  6. func fn0(obj: Person) { }
  8. // 接收遵守Livable协议的实例
  9. func fn1(obj: Livable) { }
  11. // 接收同时遵守Livable、Runnable协议的实例
  12. func fn2(obj: Livable & Runnable) { }
  14. // 接收同时遵守Livable、Runnable协议，并且是Person或者其子类的实例
  15. func fn3(obj: Person & Livable & Runnable) { }
  17. typealias RealPerson = Person & Livable & Runnable
  18. func fn4(obj: RealPerson) { }

CaseIterable

让枚举遵守CaseIterable协议，可以实现遍历枚举值

  1. enum Season: CaseIterable {
  2.     case spring, summer, autumn, winter
  3. }
  5. let seasons = Season.allCases
  6. print(seasons.count)
  8. for season in seasons {
  9.     print(season)
  10. } // spring, summer, autumn, winter

CustomStringConvertible

遵守CustomStringConvertible、CustomDebugStringConvertible协议，都可以自定义实例的打印字符串

  1. class Person: CustomStringConvertible, CustomDebugStringConvertible {
  2.     var age = 0
  3.     var description: String { "person_\(age)" }
  4.     var debugDescription: String { "debug_person_\(age)" }
  5. }
  7. var person = Person()
  8. print(person) // person_0
  9. debugPrint(person) // debug_person_0

print调用的是CustomStringConvertible协议的description

debugPrint、po调用的是CustomDebugStringConvertible协议的debugDescription

-w529

Any、AnyObject

Swift提供了两种特殊的类型Any、AnyObject

Any可以代表任意类型（枚举、结构体、类，也包括函数类型）

  1. var stu: Any = 10
  2. stu = "Jack"
  3. stu = Size()
  1. var data = [Any]()
  2. data.append(1)
  3. data.append(3.14)
  4. data.append(Size())
  5. data.append("Jack")
  6. data.append({ 10 })

AnyObject可以代表任意类类型

在协议后面写上: AnyObject，代表只有类能遵守这个协议

-w644

在协议后面写上: class，也代表只有类能遵守这个协议

-w642

is、as

is用来判断是否为某种类型

  1. protocol Runnable {
  2.     func run()
  3. }
  5. class Person { }
  7. class Student: Person, Runnable {
  8.     func run() {
  9.         print("Student run")
  10.     }
  11.     
  12.     func study() {
  13.         print("Student study")
  14.     }
  15. }
  17. var stu: Any = 10
  18. print(stu is Int) // true
  20. stu = "Jack"
  21. print(stu is String) // true
  23. stu = Student()
  24. print(stu is Person) // true
  25. print(stu is Student) // true
  26. print(stu is Runnable) // true

as用来做强制类型转换

  1. protocol Runnable {
  2.     func run()
  3. }
  5. class Person { }
  7. class Student: Person, Runnable {
  8.     func run() {
  9.         print("Student run")
  10.     }
  11.     
  12.     func study() {
  13.         print("Student study")
  14.     }
  15. }
  17. var stu: Any = 10
  18. (stu as? Student)?.study() // 没有调用study
  20. stu = Student()
  21. (stu as? Student)?.study() // Student study
  22. (stu as! Student).study() // Student study
  23. (stu as? Runnable)?.run() // Student run
  1. var data = [Any]()
  2. data.append(Int("123") as Any)
  4. var d = 10 as Double
  5. print(d) // 10.0

元类型

X.self

X.self是一个元类型的指针，metadata存放着类型相关信息

X.self属于X.Type类型

  1. class Person { }
  3. class Student: Person { }
  5. var perType: Person.Type = Person.self
  6. var stuType: Student.Type = Student.self
  7. perType = Student.self
  9. var anyType: AnyObject.Type = Person.self
  10. anyType = Student.self
  12. var per = Person()
  13. perType = type(of: per)
  14. print(Person.self == type(of: per)) // true

AnyClass的本质就是AnyObject.Type

-w492

  1. var anyType2: AnyClass = Person.self
  2. anyType2 = Student.self

元类型的应用

  1. class Animal {
  2.     required init() {
  3.         
  4.     }
  5. }
  7. class Cat: Animal {
  8.     
  9. }
  11. class Dog: Animal {
  12.     
  13. }
  15. class Pig: Animal {
  16.     
  17. }
  19. func create(_ clses: [Animal.Type]) -> [Animal] {
  20.     var arr = [Animal]()
  21.     for cls in clses {
  22.         arr.append(cls.init())
  23.     }
  24.     
  25.     return arr
  26. }
  28. print(create([Cat.self, Dog.self, Pig.self]))
  30. // a1、a2、a3、a4的写法等价
  31. var a1 = Animal()
  32. var t = Animal.self
  33. var a2 = t.init()
  34. var a3 = Animal.self.init()
  35. var a4 = Animal.self()

Self

Self代表当前类型

  1. class Person {
  2.     var age = 1
  3.     static var count = 2
  4.     
  5.     func run() {
  6.         print(self.age)
  7.         print(Self.count)
  8.     }
  9. }

Self一般用作返回值类型，限定返回值和方法调用者必须是同一类型（也可以作为参数类型）

  1. protocol Runnable {
  2.     func test() -> Self
  3. }
  5. class Person: Runnable {
  6.     
  7.     required init() {
  8.         
  9.     }
  10.     
  11.     func test() -> Self {
  12.         type(of: self).init()
  13.     }
  14. }
  16. class Student: Person {
  17.     
  18. }
  20. var p = Person()
  21. print(p.test()) // test_enum.Person
  23. var stu = Student()
  24. print(stu.test()) // test_enum.Student

元类型的本质

我们可以通过反汇编来查看元类型的实现是怎样的

  1. var p = Person()
  2. var pType = Person.self

我们发现最后存储到全局变量pType中的地址值就是一开始调用的地址

-w1031

再通过打印，我们发现pType的值就是Person实例对象的前8个字节的地址值，也就是类信息

-w1031
-w1032

我们再来看下面的示例代码

  1. var p = Person()
  2. var pType = type(of: p)

通过分析我们可以看到type(of: p)本质不是函数调用，只是将Person实例对象的前8个字节存储到pType中，也证明了元类型的本质就是存储的类信息

-w1031
-w1030

我们还可以用以下方式来获取Swift的隐藏基类_TtCs12_SwiftObject

  1. class Person {
  2.     var age: Int = 0
  3. }
  5. class Student: Person {
  6.     var no: Int = 0
  7. }
  9. print(class_getInstanceSize(Student.self)) // 32
  10. print(class_getSuperclass(Student.self)!) // Person
  11. print(class_getSuperclass(Student.self)!) // _TtCs12_SwiftObject
  12. print(class_getSuperclass(NSObject.self)) // nil

我们可以查看Swift源码来分析该类型

发现SwiftObject里面也有一个isa指针

-w686

原文链接：http://www.cnblogs.com/funkyRay/p/swift-jin-jie-jiu-xie-yi-yuan-lei-xing.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

iOS热门文章

  • snapkit更新约束崩溃的问题
  • iOS 14 UDP收不到广播处理
  • iOS开发用如何用类"SKStoreProductViewController"跳转AppStore点赞评分？
  • Charles抓包iPhone注意点以及SSL Proxying enabled for this host
  • 笔记：long、longlong、int、float、NSString相互转换
  • ios开发UI篇—UITextfield
  • 自定义相机碰到的问题，比如常见的拍照录制视频方向，镜像左右颠倒等问题
  • C 和 Object-C中的 #ifdef #ifndef
  • 使用Hbuilder将自己app发布到App Store（一）
  • iOS开发 - 超级签名实现之描述文件

    • iOS推荐文章

  • iOS开发基础135-Core Data
  • uniapp-vue3-oadmin手机后台实例|vite5.x+uniapp多端仿ios管理系统
  • 苹果支付有哪些坑，为什么苹果支付比支付宝和微信容易丢单？
  • 带你走进灵动岛
  • vue3+ts Axios封装—重复请求拦截
  • axios详解以及完整封装方法
  • 关于 axios 是什么？以及怎么用？
  • iOS气泡提示工具BubblePopup的使用
  • 一篇文章带你详细了解axios的封装 - 公众号-web前端进阶
  • [MAUI]模仿iOS多任务切换卡片滑动的交互实现

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号