swift协议protocol – Swift最新教程

上一章Swift教程请查看：swift扩展extension

协议为方法、属性和其他需求功能提供了蓝图，它只是被描述为一个方法或属性框架，而不是实现。方法和属性的实现可以通过定义类、函数和枚举来进一步实现。协议的一致性被定义为满足协议要求的方法或属性。

语法

协议也遵循类似于类、结构和枚举的语法

protocol SomeProtocol {
    // 协议定义 
 }

协议是在类、结构或枚举类型名之后声明的。单个和多个协议声明也是可能的。如果定义了多个协议，则必须用逗号分隔它们。

struct SomeStructure: Protocol1, Protocol2 {
    // 结构体定义
 }

当必须为超类定义协议时，协议名应该在超类名后面加上逗号。

class SomeClass: SomeSuperclass, Protocol1, Protocol2 {
    // 类定义
 }

属性和方法要求

协议用于指定特定的类类型属性或实例属性。它只是单独指定类型或实例属性，而不是指定它是存储属性还是计算属性，此外，它还用于指定属性是“可获取的”还是“可设置的”。

属性需求由’var’关键字声明为属性变量，{get set}用于在类型声明之后声明gettable和settable属性，在类型声明之后，{get}属性会提到Gettable。

protocol classa {
    var marks: Int { get set }
    var result: Bool { get }
    
    func attendance() -> String
    func markssecured() -> String
 }
 
 protocol classb: classa {
    var present: Bool { get set }
    var subject: String { get set }
    var stname: String { get set }
 }
 
 class classc: classb {
    var marks = 96
    let result = true
    var present = false
    var subject = "Swift协议"
    var stname = "协议"
 
    func attendance() -> String {
       return "\(stname) has secured 99% attendance"
    }
    func markssecured() -> String {
       return "\(stname) has scored \(marks)"
    }
 }
 
 let studdet = classc()
 studdet.stname = "Swift"
 studdet.marks = 98
 studdet.markssecured()
 
 print(studdet.marks)
 print(studdet.result)
 print(studdet.present)
 print(studdet.subject)
 print(studdet.stname)

突变方法要求

protocol daysofaweek {
    mutating func print()
 }
 
 enum days: daysofaweek {
    case sun, mon, tue, wed, thurs, fri, sat 
    mutating func print() {
       switch self {
          case sun:
             self = sun
             print("Sunday")
          case mon:
             self = mon
             print("Monday")
          case tue:
             self = tue
             print("Tuesday")
          case wed:
             self = wed
             print("Wednesday")
          case mon:
             self = thurs
             print("Thursday")
          case tue:
             self = fri
             print("Friday")
          case sat:
             self = sat
             print("Saturday")
          default:
             print("NO Such Day")
       }
    }
 }
 
 var res = days.wed
 res.print()

初始化器要求

Swing允许用户初始化协议以遵循与普通初始化器相似的类型一致性。

语法

protocol SomeProtocol {
    init(someParameter: Int)
 }

例子：

protocol tcpprotocol {
    init(aprot: Int)
 }

协议初始化器要求的类实现

指定或方便的初始化器允许用户初始化一个协议，以符合其标准的保留’required’关键字。

class SomeClass: SomeProtocol {
    required init(someParameter: Int) {
       // 初始化器实现语句
    }
 }
 
 protocol tcpprotocol {
    init(aprot: Int)
 }
 
 class tcpClass: tcpprotocol {
    required init(aprot: Int) {
    }
 }

通过“required”修饰符确保显式或继承实现的所有子类都符合协议。

当一个子类重写它的超类初始化需求时，它是由“override”修饰词关键字指定的。

protocol tcpprotocol {
    init(no1: Int)
 }
 
 class mainClass {
    var no1: Int       
    init(no1: Int) {
       self.no1 = no1  // 初始化
    }
 }
 
 class subClass: mainClass, tcpprotocol {
    var no2: Int
    init(no1: Int, no2 : Int) {
       self.no2 = no2
       super.init(no1:no1)
    }
    required override convenience init(no1: Int) {
       self.init(no1:no1, no2:0)
    }
 }
 
 let res = mainClass(no1: 20)
 let print = subClass(no1: 30, no2: 50)
 
 print("res: \(res.no1)")
 print("res: \(print.no1)")
 print("res: \(print.no2)")

协议的类型

它们被用作函数、类、方法等的类型，而不是在协议中实现功能。

协议可以作为以下中的类型访问

• 函数、方法或初始化为参数或返回类型
• 常量、变量或属性
• 数组、字典或其他容器作为项

protocol Generator {
    typealias members
    func next() -> members?
 }
 
 var items = [10,20,30].generate()
 while let x = items.next() {
    print(x)
 }
 
 for lists in map([1,2,3], {i in i*5}) {
    print(lists)
 }
 
 print([100,200,300])
 print(map([1,2,3], {i in i*10}))

添加与扩展的协议一致性

现有类型可以通过使用扩展来采用和遵守新的协议。在扩展的帮助下，可以将新的属性、方法和下标添加到现有类型中。

protocol AgeClasificationProtocol {
    var age: Int { get }
    func agetype() -> String
 }
 class Person {
    let firstname: String
    let lastname: String
    var age: Int
    
    init(firstname: String, lastname: String) {
       self.firstname = firstname
       self.lastname = lastname
       self.age = 10
    }
 }
 
 extension Person : AgeClasificationProtocol {
    func fullname() -> String {
       var c: String
       c = firstname + " " + lastname
       return c
    }
    func agetype() -> String {
       switch age {
          case 0...2:
             return "Baby"
          case 2...12:
             return "Child"
          case 13...19:
             return "Teenager"
          case let x where x > 65:
             return "Elderly"
          default:
             return "Normal"
       }
    }
 }

协议继承

Swift允许协议从其定义的属性中继承属性，它类似于类继承，但是可以选择列出由逗号分隔的多个继承协议。

protocol classa {
    var no1: Int { get set }
    func calc(sum: Int)
 }
 protocol result {
    func print(target: classa)
 }
 class student2: result {
    func print(target: classa) {
       target.calc(sum: 1)
    }
 }
 class classb: result {
    func print(target: classa) {
       target.calc(sum: 5)
    }
 }
 
 class student: classa {
    var no1: Int = 10
    
    func calc(sum: Int) {
       no1 -= sum
       print("\(sum) times")
          
       if no1 <= 0 {
          print("absent")
       }
    }
 }
 
 class Player {
    var stmark: result!
 
    init(stmark: result) {
       self.stmark = stmark
    }
    func print(target: classa) {
       stmark.print(target: target)
    }
 }
 
 var marks = Player(stmark: student2())
 var marksec = student()
 
 marks.print(target: marksec)
 marks.print(target: marksec)
 marks.print(target: marksec)
 marks.stmark = classb()
 marks.print(target: marksec)
 marks.print(target: marksec)
 marks.print(target: marksec)

类只有一个协议

在定义协议时，如果用户希望使用类定义协议，那么应该首先定义类，然后定义协议的继承列表。

protocol tcpprotocol {
    init(no1: Int)
 }
 class mainClass {
    var no1: Int       
    init(no1: Int) {
       self.no1 = no1  
    }
 }
 class subClass: mainClass, tcpprotocol {
    var no2: Int
    init(no1: Int, no2 : Int) {
       self.no2 = no2
       super.init(no1:no1)
    }
    
    required override convenience init(no1: Int) {
       self.init(no1:no1, no2:0)
    }
 }
 
 let res = mainClass(no1: 20)
 let print = subClass(no1: 30, no2: 50)
 
 print("res: \(res.no1)")
 print("res: \(print.no1)")
 print("res: \(print.no2)")

协议组成

在协议组合的帮助下，Swift允许同时调用多个协议。

语法

protocol<SomeProtocol, AnotherProtocol>

例子：

protocol stname {
    var name: String { get }
 }
 protocol stage {
    var age: Int { get }
 }
 struct Person: stname, stage {
    var name: String
    var age: Int
 }
 func print(celebrator: stname & stage) {
    print("name: \(celebrator.name), age: \(celebrator.age)")
 }
 let studname = Person(name: "AA", age: 21)
 print(studname)
 
 let stud = Person(name: "BB", age: 29)
 print(stud)
 
 let student = Person(name: "CC", age: 19)
 print(student)

协议一致性检查

协议一致性由“is”和“as”操作符进行测试，其操作符类似于类型强制转换。

• 如果实例符合协议标准，则is操作符返回true;如果失败，则返回false。
• as?向下转换操作符的版本返回协议类型的可选值，如果实例不符合该协议，则该值为nil。
• 向下转换操作符的as版本强制将类型转换为协议类型，并在向下转换类型失败时触发运行时错误。

import Foundation

@objc protocol rectangle {
   var area: Double { get }
}
@objc class Circle: rectangle {
   let pi = 3.1415927
   var radius: Double
   var area: Double { return pi * radius * radius }
   init(radius: Double) { self.radius = radius }
}
@objc class result: rectangle {
   var area: Double
   init(area: Double) { self.area = area }
}
class sides {
   var rectsides: Int
   init(rectsides: Int) { self.rectsides = rectsides }
}
let objects: [AnyObject] = [Circle(radius: 2.0),result(area:198),sides(rectsides: 4)]

for object in objects {
   if let objectWithArea = object as? rectangle {
      print("Area: \(objectWithArea.area)")
   } else {
      print("not defined")
   }
}