Swift 协议

在 Swift 中，协议定义了一系列方法或属性的蓝图，这些方法或属性随后可以被类（或其他类型）采纳。

我们使用 protocol 关键字来定义一个协议。例如：

protocol Greet {

  // blueprint of a property 
  var name: String { get }


  // blueprint of a method 
  func message() 
}    

这里，

• Greet - 协议名称
• name - 一个可读属性
• message() - 没有实现的方法定义

类遵循 Swift 协议

在 Swift 中，要使用协议，其他类必须遵循它。在类遵循协议之后，我们必须提供方法实际的实现。

以下是如何使类遵循协议：

// conform class to Greet protocol
class Employee: Greet {

  // implementation of property
  var name = "Perry"

  // implementation of method
  func message() {
    print("Good Morning!")
  }
}

在这里，我们使 Employee 类遵循了 Greet 协议。因此，我们必须提供 name 属性和 message() 方法的实际实现。

示例 1：Swift 协议

protocol Greet {
  
  // blueprint of property
  var name: String { get }

  // blueprint of a method 
  func message() 
} 

// conform class to Greet protocol
class Employee: Greet {

  // implementation of property
  var name = "Perry"

  // implementation of method
  func message() {
    print("Good Morning", name)
  }
}

var employee1 = Employee()
employee1.message()

输出

Good Morning Perry

在上面的示例中，我们创建了一个名为 Greet 的协议。该协议包含 name 属性和 message() 方法的蓝图。

在这里，Employee 类遵循 Greet 并提供了 name 和 message() 的实际实现。

示例 2：Swift 协议用于计算面积

protocol Polygon {

  func getArea(length: Int, breadth: Int)
}

// conform the Polygon protocol
class Rectangle: Polygon {

  // implementation of method
  func getArea(length: Int, breadth: Int) {
    print("Area of the rectangle:", length * breadth)
  }
}

// create an object
var r1 = Rectangle()

r1.getArea(length:5, breadth: 6)

输出

Area of the rectangle: 30

在上面的示例中，我们创建了一个名为 Polygon 的协议。该协议包含 getArea() 方法的蓝图，该方法有两个参数：length 和 breadth。

在这里，Rectangle 类遵循 Polygon 并提供了 getArea() 方法的实际实现。

func getArea(length: Int, breadth: Int) {
  print("Area of the rectangle:", length * breadth)
}

遵循多个协议

在 Swift 中，一个类也可以遵循多个协议。例如：

protocol Sum {
  ...
}

protocol Multiplication {
  ...
}

class Calculate: Sum, Multiplication {
  ...
}

在这里，名为 Calculate 的类遵循 Sum 和 Multiplication 协议。

示例 3：遵循多个协议

// create Sum protocol
protocol Sum {

  func addition()
}

// create Multiplication protocol
protocol Multiplication {

  func product()
}

// conform class to two protocols
class Calculate: Sum, Multiplication {

  var num1 = 0
  var num2 = 0

  func addition () {
    let result1 = num1 + num2
    print("Sum:", result1)
  }

  func product () {
    let result2 = num1 * num2
    print("Product:", result2)
  }
                   
}

// create an object
var calc1 = Calculate()

// assign values to properties
calc1.num1 = 5
calc1.num2 = 10

// access methods
calc1.addition()
calc1.product()

输出

Sum: 15
Product: 50

在上面的示例中，我们创建了两个协议：Sum 和 Multiplication。此外，我们创建了一个名为 Calculate 的类，该类遵循这两个协议。

我们在 Sum 和 Multiplication 协议中分别创建了名为 addition() 和 product() 的方法蓝图。

protocol Sum {

  func addition()
}

protocol Multiplication {

  func product()
}

由于 Calculate 遵循 Sum 和 Multiplication，我们在类中提供了 addition() 和 product() 的实际实现。

最后，我们使用该类的 calc1 对象访问了这些方法。

// access methods
calc1.addition()
calc1.product()

Swift 协议继承

与类类似，协议可以继承其他协议。例如：

protocol Car {
  ...
}

protocol Brand: Car {
  ...
}

在这里，Brand 协议继承了 Car 协议。现在，如果任何类实现了 Brand，它应该为 Car 和 Brand 的所有属性提供实现。

示例 4：Swift 协议继承

protocol Car {
  var colorOptions: Int { get }
}

// inherit Car protocol
protocol Brand: Car {
  var name: String { get }
}

class Mercedes: Brand {

  // must implement properties of both protocols 
  var name: String = ""
  var colorOptions: Int = 0
}

var car1 = Mercedes()
car1.name = "Mercedes AMG"
car1.colorOptions = 4

print("Name:", car1.name)
print("Color Options:", car1.colorOptions)

输出

Name: Mercedes AMG
Color Options: 4

在上面的示例中，Brand 协议继承了 Car 协议。

在这里，Mercedes 类只遵循 Brand。但由于 Brand 继承了 Car，我们需要实现 Car 和 Brand 的所有属性。

protocol A {
  ...
}
protocol B {
  ... 
}

protocol C: A, B {
  ...
}

协议扩展

在 Swift 中，我们可以使用 extension 关键字来扩展协议。例如：

// protocol definition
protocol Brake {
  func applyBrake()
}

// define class that conforms Brake
class Car: Brake {
  var speed: Int = 0

  func applyBrake() {
    print("Brake Applied")
  }
}

// extend protocol
extension Brake {
  func stop() {
    print("Engine Stopped")
  }
}

let car1 = Car()
car1.speed = 61
print("Speed:", car1.speed)

car1.applyBrake()

// access extended protocol
car1.stop()

输出

Speed: 61
Brake Applied
Engine Stopped

在上面的示例中，我们创建了一个名为 Brake 的协议，它定义了 applyBrake() 函数。

我们扩展了 Brake 协议并在其中定义了 stop() 函数。

// extend protocol
extension Brake {
  func stop() {
    print("Engine Stopped")
  }
}

我们可以使用 car1 对象访问扩展的协议。

// access extended protocol
car1.stop()