协议和面向协议的编程(POP)。

POP消除了大型,复杂的继承层次结构,并用可以组合在一起的更小,更简单的协议代替了它们。这确实是Tony Hoare多年前说的话的实现:“在每个大型程序中,都有一个小型程序试图退出。”

协议

协议是描述某物必须具有的属性和方法的一种方式。然后,您可以告诉Swift哪些类型使用该协议-这一过程称为采用或遵循协议。

例如,我们可以编写一个可以接受带有id属性的东西的函数,但是我们并不在乎使用什么类型的数据。我们将从创建一个Identifiable协议,该协议将要求所有符合条件的类型都具有一个id可以读取(“ get”)或写入(“ set”)的字符串:

1
2
3
protocol Identifiable {
var id: String { get set }
}

我们无法创建该协议的实例-它是描述,而不是类型本身。但是我们可以创建一个符合它的结构:

1
2
3
struct User: Identifiable {
var id: String
}

最后,我们将编写一个displayID()接受任何Identifiable对象的函数:

1
2
3
func displayID(thing: Identifiable) {
print("My ID is \(thing.id)")
}

其他例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
protocol Zhhoo{
var url: String {get set}
}

struct Hooweb: Zhhoo {
var url: String
}

func tozhhoo(adr: Zhhoo){
print("Let's go to the \(adr.url) !")
}

var hooto = Hooweb(url: "zhhooo.com")
tozhhoo(adr: hooto)

其他例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
protocol SuitableForKids {
var minimumAge: Int { get set }
var maximumAge: Int { get set }
}
protocol SupportsMultiplePlayers {
var minimumPlayers: Int { get set }
var maximumPlayers: Int { get set }
}
struct FamilyBoardGame: SuitableForKids, SupportsMultiplePlayers {
var minimumAge = 3
var maximumAge = 110
var minimumPlayers = 1
var maximumPlayers = 4
}

注意:
协议不能只设置仅set属性,允许仅get或者get set

继承协议

协议可以被继承。与类不同,在顶部添加自己的自定义项之前,您可以同时从多个协议继承。

我们将定义三种协议:Payable需要使用符合类型的calculateWages()方法来实现方法,NeedsTraining需要使用符合类型的study()方法来实现方法以及HasVacation需要使用符合类型的takeVacation()方法来实现方法:

1
2
3
4
5
6
7
8
9
10
11
protocol Payable {
func calculateWages() -> Int
}

protocol NeedsTraining {
func study()
}

protocol HasVacation {
func takeVacation(days: Int)
}

现在,我们可以创建一个Employee协议,将它们组合成一个协议。我们不需要在顶部添加任何内容,因此我们只需要写大括号即可:

1
protocol Employee: Payable, NeedsTraining, HasVacation { }

现在,我们可以使新类型符合该单一协议,而不是三个单独协议中的每个。

其他例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
protocol Zhhoo {
func towebsite() -> Int
}

protocol Chrome {
func url()
}

protocol Mac {
func link()
}

protocol go: Zhhoo,Chrome,Mac {}

其他例子:

1
2
3
4
5
6
7
8
9
protocol CarriesPassengers {
var passengerCount: Int { get set }
}
protocol CarriesCargo {
var cargoCapacity: Int { get set }
}
protocol Boat: CarriesPassengers, CarriesCargo {
var name: String { get set }
}

扩展

扩展允许您向现有类型添加方法,以使它们执行原本不是设计要执行的操作。

例如,我们可以在Int类型中添加扩展名,以便它具有squared()返回当前数字乘以自身的方法,利用extension

1
2
3
4
5
extension Int {
func squared() -> Int {
return self * self
}
}

要尝试该方法,只需创建一个整数,您将看到它现在有一个squared()方法:

1
2
let number = 8
number.squared()

Swift不允许您在扩展中添加存储的属性,因此必须改用计算属性。例如,我们可以isEven向整数添加一个新的计算属性,如果该属性包含偶数,则返回true:

1
2
3
4
5
extension Int {
var isEven: Bool {
return self % 2 == 0
}
}

其他例子:

1
2
3
4
5
6
7
8
9
extension String {
mutating func append(_ other: String) {
self += other
}
}

var web = "https://"
web.append("zhhooo.com")
print(web)

其他例子:

1
2
3
4
5
6
7
8
9
10
11
12
extension Bool {
func toggled() -> Bool {
if self == true {
return false
} else {
return true
}
}
}

var web = true
web.toggled()

其他例子:

1
2
3
4
5
6
7
8
9
10
11
extension Int {
func clamped(min: Int, max: Int) -> Int {
if (self > max) {
return max
} else if (self < min) {
return min
}
return self

}
}

协议扩展

协议可让您描述某物应具有的方法,但不提供内部代码。扩展使您可以在方法内部提供代码,但只影响一种数据类型–您不能同时将方法添加到许多类型中。

协议扩展解决了这两个问题:它们类似于常规扩展,除了扩展特定Int协议(如扩展整个协议)以使所有符合条件的类型都可以进行更改外,它们都可以扩展。

例如,这是一个数组和一个包含一些名称的集合:

1
2
let pythons = ["Eric", "Graham", "John", "Michael", "Terry", "Terry"]
let beatles = Set(["John", "Paul", "George", "Ringo"])

Swift的数组和集合都符合称为的协议Collection,因此我们可以对该协议编写一个扩展,以添加一种summarize()方法来整齐地打印集合

1
2
3
4
5
6
7
8
9
extension Collection {
func summarize() {
print("There are \(count) of us:")

for name in self {
print(name)
}
}
}

无论Array和Set现在有一个方法,所以我们可以尝试一下:

1
2
pythons.summarize()
beatles.summarize()

其他例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
protocol Politician {
var isDirty: Bool { get set }
func takeBribe()
}
extension Politician {
func takeBribe() {
if isDirty {
print("Thank you very much!")
} else {
print("Someone call the police!")
}
}
}

其他例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
protocol Anime {
var availableLanguages: [String] { get set }
func watch(in language: String)
}
extension Anime {
func watch(in language: String) {
if availableLanguages.contains(language) {
print("Now playing in \(language)")
} else {
print("Unrecognized language.")
}
}
}

其他例子:

1
2
3
4
5
6
7
8
protocol Mammal {
func eat()
}
extension Mammal {
func eat() {
print("Time for dinner!")
}
}

面向协议的编程

协议扩展可以为我们自己的协议方法提供默认实现。这使类型很容易符合协议,并允许使用一种称为“面向协议的编程”的技术–围绕协议和协议扩展来编写代码。

首先,这是一个称为的协议Identifiable,它要求任何符合条件的类型都具有id属性和identify()方法:

1
2
3
4
protocol Identifiable {
var id: String { get set }
func identify()
}

我们可以使每个符合条件的类型都编写自己的identify()方法,但是协议扩展允许我们提供默认值:

1
2
3
4
5
extension Identifiable {
func identify() {
print("My ID is \(id).")
}
}

现在,当我们创建一个符合Identifiable它的类型时,它会identify()自动获取:

1
2
3
4
5
6
struct User: Identifiable {
var id: String
}

let twostraws = User(id: "twostraws")
twostraws.identify()

总结

  • 协议描述了一致性类型必须具有的方法和属性,但未提供这些方法的实现。
  • 您可以在类似于类的其他协议之上构建协议。
  • 扩展允许您将方法和计算属性添加到特定类型,例如Int。
  • 协议扩展使您可以向协议添加方法和计算的属性。
  • 面向协议的编程是一种将应用程序体系结构设计为一系列协议,然后使用协议扩展来提供默认方法实现的实践。

参考资料

查看下一天的SwiftUI学习笔记

关于100days英文课程