Swift协议Protocol介绍

协议（Protocol）是Swift语言中对类、结构体、枚举等类型进行规范和限制的一种机制，类似于其他编程语言中的接口（Interface）概念。协议描述了一系列要求，定义了类型所应实现的方法、属性和其他成分。当某个类型满足了协议要求，我们就说该类型“遵循了”或者“实现了”该协议。

基本语法

定义一个协议，使用protocol关键字：

protocol ProtocolName {
    // 协议内容
}

协议中可以包含若干个要求，例如方法、属性、下标、种类、嵌套类型、可选要求等。要求的语法如下：

• 定义方法

protocol ProtocolName {
    func methodName()
}

• 定义属性

protocol ProtocolName {
    var propertyName: Type { get set }
}

• 定义下标

protocol ProtocolName {
    subscript(index: Int) -> Type { get set }
}

• 定义关联类型

protocol ProtocolName {
    associatedtype AssociatedType
}

• 定义嵌套类型

protocol ProtocolName {
    associatedtype NestedType
    struct NestedStruct {}
    class NestedClass {}
    enum NestedEnum {}
}

• 定义可选要求

@objc protocol ProtocolName {
    @objc optional func optionalMethod() -> Type
    @objc optional var optionalProperty: Type { get set }
}

协议的遵循

定义协议之后，我们可以让任何一个类(class)、结构体(struct)、枚举(enum)遵循该协议。

遵循协议，使用type: ProtocolName这样的语法来声明，例如：

class SomeClass: ProtocolName {
    // 实现协议内容
}

若该类实现该协议的所有要求，即可称该类遵循该协议。

使用协议作为类型，并调用遵循该协议的实例的协议内容，例如：

protocol ProtocolName {
    func sayHello()
}

class SomeClass: ProtocolName {
    func sayHello() {
        print("Hello, World!")
    }
}

// 创建遵循协议的实例
let instance: ProtocolName = SomeClass()

// 调用协议内容
instance.sayHello() // 输出 "Hello, World!"

示例一：Delegate模式

协议的常见使用场景是Delegate模式，在这个模式中，一个对象将自身的状态与交互分发给另一个对象，以实现对象间的松耦合协作。

例如，iOS中许多控件都实现了Delegate模式，将某一事件的响应处理交给了委托对象，例如UITextFieldDelegate协议。

定义一个协议，例：

protocol TextFiledDelegate {
    func textFieldShouldReturn(_ textField: UITextField) -> Bool
}

遵循协议的class，例：

class ViewController: UIViewController, UITextFieldDelegate {
    // 省略其他代码。
}

使用遵循协议的class实现协议方法，例：

class ViewController: UIViewController, UITextFieldDelegate {

    func textFieldShouldReturn(_ textField: UITextField) -> Bool {
        // 隐藏键盘
        textField.resignFirstResponder()
        return true // 代表输入结束
    }
}

示例二：装饰器模式

另一个协议的使用场景是将对象装饰起来，以增加其功能。例如，我们可能需要在运行时为某个对象添加日志、缓存、或者其他功能，以及将不同的装饰器组合起来。

定义一个协议来表示装饰器模式，例：

protocol Decorator: Component {
    var component: Component { get set }
}

这里使用了类似于“洋葱模型”的概念，每一个装饰器都持有一个内部的被装饰的组件对象，其自身也遵循了Component协议。在Decorator协议中，我们定义了一个component属性，用于获取和修改被装饰的Component对象。

遵循Decorator协议的装饰器实现，例：

class LogDecorator: Decorator {
    var component: Component // 必须实现

    required init(_ component: Component) {
        self.component = component
    }

    func operation() -> String {
        let result = component.operation()
        print("Log: \(result)")
        return result
    }
}

可以将多个装饰器组合在一起，例：

// 创建Component对象
let component: Component = ConcreteComponent()

// 为Component对象添加装饰器
let logDecorator: Decorator = LogDecorator(component)
let cacheDecorator: Decorator = CacheDecorator(logDecorator)

let result = cacheDecorator.operation()

结语

本文介绍了Swift协议的基本语法、协议遵循以及协议的两个使用场景。协议机制是Swift语言中强大的特性之一，可以帮助我们设计灵活、可复用的代码。