Swift 中的协议和扩展

2021-03-12 本文已影响0人孤雁_南飞

协议

协议的语法

自定义类型声明时，将协议名放在类型名的冒号之后来表示该类型采纳一个特定的协议。多个协议可以用都好分开列出
若一个类拥有父类，将这个父类名放在其采纳的谢一鸣钱，并用都好分隔

protocol SomeProtocol {
    
}
protocol OneProtocol {
    
}

struct SomeStructure: SomeProtocol {
    
}
class SomeStre: SomeProtocol, OneProtocol {
    
}

属性要求

协议可以要求所有遵循该协议的类型提供特定名字和类型的实例属性或类型属性。协议并不会具体说明属性是存储型属性还是计算型属性--它只具体要求属性有特定的名称和类型。协议同事要求一个属性必须明确是可读的，或可读的和可写的
若协议要求一个属性为可读和可写的，那么该属性要求不能用常量存储属性或只读计算属性来满足。若协议只要求属性为可读的，那么任何种类的属性都能满足这个要求，而且如果你的代码需要的话，该属性也可以使可写的。

protocol SomeProtocol {
    var mustBeSettable: Int { get set }
    var doesNotNeedToBeSettable: Int {get}  
}

protocol FullyNamed {
    var fullName: String { get }
}
struct Person: FullyNamed {
    var fullName: String
}
let john = Person(fullName: "John AppleSeed")

class Starship: FullyNamed {
    var prefix: String?
    var name: String
    init(name: String, prefix: String? = nil) {
        self.name   = name
        self.prefix = prefix
    }
    var fullName: String {
        return ((prefix != nil) ? (prefix! + "") : "" ) + name
    }
}
var ncc = Starship(name: "Enterprise", prefix: "USS")

属性要求

在协议中定义类型属性时，在前面添加 static 关键字。当类的实现使用 class 或 static 关键字前缀声明类型属性要求时，这个规则仍然适用。

protocol AnotherProtocol {
    static var someTypeProperty: Int { get set }
}

方法要求

协议可以要求采纳的类型实现指定的实例方法和类方法。这些方法作为协议定义的一部分，书写方式与正常实例和类方法的方式完全相同，但是不需要大括号和方法的主体。允许拥有参数，与正常的方法使用同样的规则。但在协议的定义中，方法参数不能定义默认值。
正如类型属性要求的那样，当协议中定义类型方法时，你总要在其之前添加 static 关键字。即使在类实现时，类型方法要求使用 class 或 static 作为关键字前缀，签名的规则仍然适用。

mutating 方法要求

若你定义了一个协议的实例方法需求，想要异变任何采用了该协议的类型实例，只需在协议里方法的定义当中使用 mutating 关键字。这允许结构体和枚举类型能采用相应协议并满足方法要求

初始化器要求

协议写在要求遵循协议的类型实现指定的初始化器。和一般的初始化器一样，只用将初始化器写在协议的定义当中，只是不用写大括号也就是初始化器的实体

protocol SomeProtocol {
    init(someParameter: Int)  
}

初始化器要求的类实现

你可以通过实现指定初始化器或便捷初始化器来遵循该协议的类满足协议的初始化器要求。在这两种情况下，你都必须使用 required 关键字修饰初始化器的实现。

protocol SomeProtocol {
    init(someParameter: Int)
}
class SomeClass: SomeProtocol {
    required init(someParameter: Int) {
        
    }
}

如果一个子类重写了父类指定的初始化器，并且遵循协议实现了初始化器要求，那么就要为这个初始化器的实现添加 required 和 override 两个修饰符。

protocol SomeProtocol {
    init()
}
class SomeSuperClass {
    init() {
        
    }
}
class SomeSubClass: SomeSuperClass, SomeProtocol {
    required override init() {
        
    }
}

将协议作为类型

在函数、方法或初始化器里作为形式参数类型或者返回类型
作为常量、变量或者属性的类型；
作为数组、字典或者其他存储器的元素的类型

协议继承

协议可以继承一个或者多个其他协议并且可以在它继承的基础上添加更多要求。协议继承的语法与类继承的语法相似，只不过可以选择列出多个继承的协议，使用逗号分隔。

protocol SomeProtocol { 
    
}
protocol AnotherProtocol {
    
}
protocol InheritingProtocol: SomeProtocol, AnotherProtocol {
    
}

类专用的协议

通过添加 AnyObject 关键字到协议的继承列表，你就可以限制协议只能被类类型采纳(并且不是结构体或枚举)。

protocol AnotherProtocol {
    
} 

protocol SomeClassOnlyProtocol: AnyObject, AnotherProtocol {
    
}

协议组合

可以使用协议组合来复用多个协议到一个要求里。协议组合行为就和你定义的临时局部协议已于，拥有构成中所有协议的需求。协议组合补丁已任何新的协议类型。
协议组合使用 Name & Aged 的形式。你可以列举任意数量的协议，用和符号(&) 连接。处理协议列表、协议组合也能包含类类型，这允许你标明一个需要的父类

protocol Named {
    var name: String { get }
}
protocol Aged {
    var age: Int { get }
}
struct Person: Named, Aged {
    var name: String
    var age: Int
}
func wishHappyBirthday(to celebrator: Named & Aged) {
    print("Happy birthday, \(celebrator.name), you're \(celebrator.age)")
}
let birthdayPerson = Person(name: "Malolm", age: 21)
wishHappyBirthday(to: birthdayPerson)

可选协议要求

你可以给协议定义可选要求，这些要求不需要强制遵循协议的类型实现。可选要求使用 optional 修饰符作为前缀放在协议的定义中。可选要求允许你的代码与 Objective-C 操作。协议和可选要求必须使用 @objc 标志标记。注意 @objc 协议只能被继承自 Objective-C 类或其他 @objc 类采纳。他们不能被结构体或者枚举采纳。

协议和扩展

在扩展里添加协议遵循

你可以扩展一个已经存在的类型来采纳和遵循一个新的协议，就算是你无法访问现有类型的源代码也行。扩展可以添加新的属性、方法和下标到已经存在的类型，并且因此允许你添加协议需要的任何需要。

protocol Named {
    var name: String { get }
}
protocol Aged {
    var age: Int { get }
}
struct Person: Named, Aged {
    var name: String
    var age: Int
}
protocol TextRepresentable {
    var desc: String { get }
}

extension Person: TextRepresentable {
    var desc: String {
        return "name \(name) age \(age)"
    }
}
let p = Person(name: "zhangsan", age: 20)
print(p.desc)

有条件的遵循协议

泛型类型可能只在某些情况下满足一个协议的要求，比如当类型的泛型形式参数遵循对应协议时。你可以通过在扩展类型时列出限制让泛型类型有条件地遵循某协议。在你采纳协议的名字后面写泛型 where 分句

extension Array: TextRepresentable where Element: TextRepresentable {
    var desc: String {
        let itemDesc = self.map{ $0.desc }
        return itemDesc.joined(separator: ",")
    }
}
let array = [Person(name: "zhangsan", age: 20), Person(name: "lisi", age: 35)]
print(array.desc)

使用扩展声明采纳协议

如果一个类型已经遵循了协议的所有需求，但是还没有声明它采纳了这个协议，你可以让通过一个空的扩展来让它采纳这个协议

protocol TextRepresentable {
    var desc: String { get }
}
struct Hamster {
    var name: String
    var desc: String {
        return "A hamster named \(name)"
    }
}

extension Hamster: TextRepresentable{}

协议扩展

协议可以通过扩展来提供方法和属性的实现以遵循类型。这就允许你在协议自身定义行为，而不是在每一个遵循或者在全局函数里定义。

extension Collection where Iterator.Element: TextRepresentable {
    var desc: String {
        let itemDesc = self.map{ $0.desc }
        return itemDesc.joined(separator: ",")
    }
}

提供默认实现

你可以使用协议扩展来给协议的任意方法或者计算属性要求提供默认实现。如果遵循类型给这个协议的要求提供了它自己的实现，那么它就会替代扩展中提供的默认实现

给协议扩展添加限制

当你定义一个协议扩展，你可以明确遵循类型必须在扩展的方法和属性可用之前满足的限制。在扩展协议名字后边使用 where 分句来写这些限制。

协议的关联类型

关联类型

定义一个协议时，有时在协议定义里声明一个或多个关联类型是很有用的。关联类型给协议中用到的类型一个占位符名称。知道采纳协议时，才指定用于该关联类型的实际类型。关联类型通过 associatedtype 关键字指定。

关联类型的应用

这个协议没有指定元素如何储存在容器中，也没指定允许存入容器的元素类型。协议仅仅指定了想成为一个 Container 的类型，必须提供的三种功能。遵循该协议的类型可以提供其他功能，只要满足这三个要求即可
任何遵循 Container 协议的类型必须能指定其存储值的类型。尤其是它必须保证只有正确类型的元素才能添加到容器中，而且该类型下标返回的元素类型必须是正确的。
为了定义这些要求， Container 协议需要一种在不知道容器具体类型的情况下，引用该容器将存储的元素类型的方法。 Container 协议需要制定所有传给 append(_:) 方法的值必须和容器里元素的值类型是一样的，而且容器下标返回的值也是和容器里元素的值类型相同。

protocol Container {
    associatedtype ItemType  //观察类型 
    mutating func append(_ item: ItemType)
    var count: Int { get }
    subscript(i: Int) -> ItemType { get }
}

struct IntStack: Container {
    var items = [Int]()
    mutating func push(_ item: Int) {
        items.append(item)
    }
    mutating func pop() -> Int {
        return items.removeLast()
    }
     
    typealias ItemType = Int 
    mutating func append(_ item: Int) {
        self.push(item)
    }
    var count: Int {
        return items.count
    }
    subscript(i: Int) -> Int {
        return items[i]
    }
}


//泛型
struct Stack<Element>: Container {
    var items = [Element]()
    mutating func push(_ item: Element) {
        items.append(item)
    }
    mutating func pop() -> Element {
        return items.removeLast()
    }
      
    mutating func append(_ item: Element) {
        self.push(item)
    }
    var count: Int {
        return items.count
    }
    subscript(i: Int) -> Element {
        return items[i]
    }
}

关联类型的约束

你可以在协议里给关联类型添加约束来要求遵循的类型满足约束。

protocol Container {
    associatedtype ItemType: Equatable
    mutating func append(_ item: ItemType)
    var count: Int { get }
    subscript(i: Int) -> ItemType { get }
}

在关联类型约束里使用协议

协议可以作为它自身的要求出现

protocol SuffixableContainer: Container {
    associatedtype Suffix: SuffixableContainer where Suffix.ItemType == ItemType
    func suffix(_ size: Int) -> Suffix
}

Swift 中的协议和扩展

协议

协议和扩展

协议的关联类型

猜你喜欢

热点阅读