Swift 3 协议 ( protocol )

协议规定了用来实现某一特定功能所必需的方法和属性

任意能够满足协议要求的类型被称为遵循(conform)这个协议

类,结构体或枚举类型都可以遵循协议,并提供具体实现来完成协议定义的方法和功能

语法

Swift 使用 protocol 关键字定义协议的语法格式如下

  1. protocol SomeProtocol
  2. {
  3. // 协议内容
  4. }

要使类遵循某个协议,需要在类型名称后加上协议名称,中间以冒号 : 分隔,作为类型定义的一部分

遵循多个协议时,各协议之间用逗号 , 分隔

  1. struct SomeStructure: FirstProtocol, AnotherProtocol
  2. {
  3. // 结构体内容
  4. }

如果类在遵循协议的同时拥有父类,应该将父类名放在协议名之前,以逗号 , 分隔

  1. class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol
  2. {
  3. // 类的内容
  4. }

对属性的规定

协议用于指定特定的实例属性或类属性,而不用指定是存储型属性或计算型属性

此外还必须指明是只读的还是可读可写的

协议中的通常用 var 来声明变量属性,在类型声明后加上 { set get } 来表示属性是可读可写的

只读属性则用 { get } 来表示

  1. import Cocoa
  2. protocol classa
  3. {
  4. var marks: Int { get set }
  5. var result: Bool { get }
  6. func attendance() -> String
  7. func markssecured() -> String
  8. }
  9. protocol classb: classa
  10. {
  11. var present: Bool { get set }
  12. var subject: String { get set }
  13. var stname: String { get set }
  14. }
  15. class classc: classb
  16. {
  17. var marks = 96
  18. let result = true
  19. var present = false
  20. var subject = "Swift 协议"
  21. var stname = "Protocols"
  22. func attendance() -> String {
  23. return "The \(stname) has secured 99% attendance"
  24. }
  25. func markssecured() -> String {
  26. return "\(stname) has scored \(marks)"
  27. }
  28. }
  29. let studdet = classc()
  30. studdet.stname = "Swift"
  31. studdet.marks = 98
  32. studdet.markssecured()
  33. print(studdet.marks)
  34. print(studdet.result)
  35. print(studdet.present)
  36. print(studdet.subject)
  37. print(studdet.stname)

编译运行以上 Swift 范例,输出结果为

  1. $ swift main.swift
  2. 98
  3. true
  4. false
  5. Swift 协议
  6. Swift

对 mutating 方法的规定

有时需要在方法中改变它的实例

例如,值类型(结构体,枚举)的实例方法中,将 mutating 关键字作为函数的前缀,写在 func 之前,表示可以在该方法中修改它所属的实例及其实例属性的值

  1. import Cocoa
  2. protocol daysofaweek
  3. {
  4. mutating func show()
  5. }
  6. enum days: daysofaweek
  7. {
  8. case sun, mon, tue, wed, thurs, fri, sat
  9. mutating func show() {
  10. switch self {
  11. case .sun:
  12. self = .sun
  13. print("Sunday")
  14. case .mon:
  15. self = .mon
  16. print("Monday")
  17. case .tue:
  18. self = .tue
  19. print("Tuesday")
  20. case .wed:
  21. self = .wed
  22. print("Wednesday")
  23. case .thurs:
  24. self = .thurs
  25. print("Wednesday")
  26. case .fri:
  27. self = .fri
  28. print("Wednesday")
  29. case .sat:
  30. self = .sat
  31. print("Saturday")
  32. default:
  33. print("NO Such Day")
  34. }
  35. }
  36. }
  37. var res = days.wed
  38. res.show()

编译运行以上 Swift 范例,输出结果为

  1. $ swift main.swift
  2. Wednesday

对构造器的规定

协议可以要求它的遵循者实现指定的构造器

可以像书写普通的构造器那样,在协议的定义里写下构造器的声明,但不需要写花括号和构造器的实体

  1. protocol SomeProtocol
  2. {
  3. init(someParameter: Int)
  4. }

比如

  1. protocol tcpprotocol {
  2. init(aprot: Int)
  3. }

协议构造器规定在类中的实现

可以在遵循该协议的类中实现构造器,并指定其为类的指定构造器或者便利构造器

在这两种情况下,都必须给构造器实现标上 required 修饰符

  1. class SomeClass: SomeProtocol
  2. {
  3. required init(someParameter: Int)
  4. {
  5. // 构造器实现
  6. }
  7. }
  8. protocol tcpprotocol
  9. {
  10. init(aprot: Int)
  11. }
  12. class tcpClass: tcpprotocol
  13. {
  14. required init(aprot: Int)
  15. {
  16. }
  17. }

使用 required 修饰符可以保证:

所有的遵循该协议的子类,同样能为构造器规定提供一个显式的实现或继承实现

如果一个子类重写了父类的指定构造器,并且该构造器遵循了某个协议的规定,那么该构造器的实现需要被同时标示 requiredoverride 修饰符

  1. protocol tcpprotocol
  2. {
  3. init(no1: Int)
  4. }
  5. class mainClass
  6. {
  7. var no1: Int // 局部变量
  8. init(no1: Int) {
  9. self.no1 = no1 // 初始化
  10. }
  11. }
  12. class subClass: mainClass, tcpprotocol
  13. {
  14. var no2: Int
  15. init(no1: Int, no2 : Int) {
  16. self.no2 = no2
  17. super.init(no1:no1)
  18. }
  19. // 因为遵循协议,需要加上"required"; 因为继承自父类,需要加上"override"
  20. required override convenience init(no1: Int) {
  21. self.init(no1:no1, no2:0)
  22. }
  23. }
  24. let res = mainClass(no1: 20)
  25. let show = subClass(no1: 30, no2: 50)
  26. print("res is: \(res.no1)")
  27. print("res is: \(show.no1)")
  28. print("res is: \(show.no2)")

编译运行以上 Swift 范例,输出结果为

  1. $ swift main.swift
  2. res is: 20
  3. res is: 30
  4. res is: 50

协议类型

尽管协议本身并不实现任何功能,但是协议可以被当做类型来使用

协议可以像其它普通类型一样使用,使用场景:

1.作为函数、方法或构造器中的参数类型或返回值类型 2.作为常量、变量或属性的类型 3.作为数组、字典或其他容器中的元素类型

  1. import Cocoa
  2. protocol Generator
  3. {
  4. associatedtype members
  5. func next() -> members?
  6. }
  7. var items = [10,20,30].makeIterator()
  8. while let x = items.next()
  9. {
  10. print(x)
  11. }
  12. for lists in [1,2,3].map( {i in i*5})
  13. {
  14. print(lists)
  15. }
  16. print([100,200,300])
  17. print([1,2,3].map({i in i*10}))

编译运行以上 Swift 范例,输出结果为

  1. $ swift main.swift
  2. 10
  3. 20
  4. 30
  5. 5
  6. 10
  7. 15
  8. [100, 200, 300]
  9. [10, 20, 30]

在扩展中添加协议成员

可以可以通过扩展来扩充已存在类型( 类,结构体,枚举等)

扩展可以为已存在的类型添加属性,方法,下标脚本,协议等成员

  1. import Cocoa
  2. protocol AgeClasificationProtocol
  3. {
  4. var age: Int { get }
  5. func agetype() -> String
  6. }
  7. class Person
  8. {
  9. let firstname: String
  10. let lastname: String
  11. var age: Int
  12. init(firstname: String, lastname: String)
  13. {
  14. self.firstname = firstname
  15. self.lastname = lastname
  16. self.age = 10
  17. }
  18. }
  19. extension Person : AgeClasificationProtocol
  20. {
  21. func fullname() -> String
  22. {
  23. var c: String
  24. c = firstname + " " + lastname
  25. return c
  26. }
  27. func agetype() -> String
  28. {
  29. switch age {
  30. case 0...2:
  31. return "Baby"
  32. case 2...12:
  33. return "Child"
  34. case 13...19:
  35. return "Teenager"
  36. case let x where x > 65:
  37. return "Elderly"
  38. default:
  39. return "Normal"
  40. }
  41. }
  42. }

协议的继承

协议能够继承一个或多个其他协议,可以在继承的协议基础上增加新的内容要求

协议的继承语法与类的继承相似,多个被继承的协议间用逗号 (,) 分隔

语法

  1. protocol InheritingProtocol: SomeProtocol, AnotherProtocol {
  2. // 协议定义
  3. }

范例

  1. protocol Classa
  2. {
  3. var no1: Int { get set }
  4. func calc(sum: Int)
  5. }
  6. protocol Result
  7. {
  8. func print(target: Classa)
  9. }
  10. class Student2: Result
  11. {
  12. func print(target: Classa)
  13. {
  14. target.calc(1)
  15. }
  16. }
  17. class Classb: Result
  18. {
  19. func print(target: Classa)
  20. {
  21. target.calc(5)
  22. }
  23. }
  24. class Student: Classa
  25. {
  26. var no1: Int = 10
  27. func calc(sum: Int) {
  28. no1 -= sum
  29. print("学生尝试 \(sum) 次通过")
  30. if no1 <= 0 {
  31. print("学生缺席考试")
  32. }
  33. }
  34. }
  35. class Player
  36. {
  37. var stmark: Result!
  38. init(stmark: Result)
  39. {
  40. self.stmark = stmark
  41. }
  42. func print(target: Classa)
  43. {
  44. stmark.print(target)
  45. }
  46. }
  47. var marks = Player(stmark: Student2())
  48. var marksec = Student()
  49. marks.print(marksec)
  50. marks.print(marksec)
  51. marks.print(marksec)
  52. marks.stmark = Classb()
  53. marks.print(marksec)
  54. marks.print(marksec)
  55. marks.print(marksec)

编译运行以上 Swift 范例,输出结果为

  1. $ swift main.swift
  2. 学生尝试 1 次通过
  3. 学生尝试 1 次通过
  4. 学生尝试 1 次通过
  5. 学生尝试 5 次通过
  6. 学生尝试 5 次通过
  7. 学生缺席考试
  8. 学生尝试 5 次通过
  9. 学生缺席考试

类专属协议

可以在协议的继承列表中,通过添加 class 关键字,限制协议只能适配到类(class)类型

class 关键字必须是第一个出现在协议的继承列表中,其后,才是其他继承协议

语法

  1. protocol SomeClassOnlyProtocol: class, SomeInheritedProtocol
  2. {
  3. // 协议定义
  4. }

范例

  1. protocol TcpProtocol
  2. {
  3. init(no1: Int)
  4. }
  5. class MainClass
  6. {
  7. var no1: Int // 局部变量
  8. init(no1: Int) {
  9. self.no1 = no1 // 初始化
  10. }
  11. }
  12. class SubClass: MainClass, TcpProtocol
  13. {
  14. var no2: Int
  15. init(no1: Int, no2 : Int) {
  16. self.no2 = no2
  17. super.init(no1:no1)
  18. }
  19. // 因为遵循协议,需要加上"required"; 因为继承自父类,需要加上"override"
  20. required override convenience init(no1: Int) {
  21. self.init(no1:no1, no2:0)
  22. }
  23. }
  24. let res = MainClass(no1: 20)
  25. let show = SubClass(no1: 30, no2: 50)
  26. print("res is: \(res.no1)")
  27. print("res is: \(show.no1)")
  28. print("res is: \(show.no2)")

编译运行以上 Swift 范例,输出结果为

  1. $ swift main.swift
  2. res is: 20
  3. res is: 30
  4. res is: 50

协议合成

Swift 支持合成多个协议,在需要同时遵循多个协议时非常有用,一般用在形参声明中

协议合成使用 & 符号

语法

下面的代码使用 & 声明一个参数必须遵循多个协议

  1. func show(celebrator: Stname & Stage)
  2. {
  3. print("\(celebrator.name) is \(celebrator.age) years old")
  4. }

范例

  1. protocol Stname
  2. {
  3. var name: String { get }
  4. }
  5. protocol Stage
  6. {
  7. var age: Int { get }
  8. }
  9. struct Person: Stname, Stage
  10. {
  11. var name: String
  12. var age: Int
  13. }
  14. func show(celebrator: Stname & Stage)
  15. {
  16. print("\(celebrator.name) is \(celebrator.age) years old")
  17. }
  18. let studname = Person(name: "Priya", age: 21)
  19. print(studname)
  20. let stud = Person(name: "Rehan", age: 29)
  21. print(stud)
  22. let student = Person(name: "Roshan", age: 19)
  23. print(student)

编译运行以上 Swift 范例,输出结果为

  1. Person(name: "Priya", age: 21)
  2. Person(name: "Rehan", age: 29)
  3. Person(name: "Roshan", age: 19)

检验协议的一致性

使用 isas 操作符来检查是否遵循某一协议或强制转化为某一类型

  • is 操作符用来检查实例是否 遵循了某个 协议

  • as? 返回一个可选值,当实例 遵循 协议时,返回该协议类型;否则返回 nil

  • as 用以强制向下转型,如果强转失败,会引起运行时错误

下面的代码定义了一个 HasArea 的协议,要求有一个 Double 类型可读的 area

  1. protocol HasArea {
  2. var area: Double { get }
  3. }
  4. // 定义了Circle类,都遵循了HasArea协议
  5. class Circle: HasArea {
  6. let pi = 3.1415927
  7. var radius: Double
  8. var area: Double { return pi * radius * radius }
  9. init(radius: Double) { self.radius = radius }
  10. }
  11. // 定义了Country类,都遵循了HasArea协议
  12. class Country: HasArea {
  13. var area: Double
  14. init(area: Double) { self.area = area }
  15. }
  16. // Animal是一个没有实现HasArea协议的类
  17. class Animal {
  18. var legs: Int
  19. init(legs: Int) { self.legs = legs }
  20. }
  21. let objects: [AnyObject] = [
  22. Circle(radius: 2.0),
  23. Country(area: 243_610),
  24. Animal(legs: 4)
  25. ]
  26. for object in objects {
  27. // 对迭代出的每一个元素进行检查,看它是否遵循了HasArea协议
  28. if let objectWithArea = object as? HasArea {
  29. print("面积为 \(objectWithArea.area)")
  30. } else {
  31. print("没有面积")
  32. }
  33. }

编译运行以上 Swift 范例,输出结果为

  1. $ swift main.swift
  2. 面积为 12.5663708
  3. 面积为 243610.0
  4. 没有面积