ReportsiOS-SwiftSwift开发实战

Swift中协议的简单介绍

2016-12-15  本文已影响1553人  老板娘来盘一血

前言

熟悉Objective-C语言的同学们肯定对协议都不陌生，在Swift中苹果将protocol这种语法发扬的更加深入和彻底。Swift中的protocol不仅能定义方法还能定义属性，配合extension扩展的使用还能提供一些方法的默认实现，而且不仅类可以遵循协议，现在的枚举和结构体也能遵循协议了。基于此本文从** 1、协议中定义属性和方法，2、协议的继承、聚合、关联类型，3、协议的扩展，4、Swift标准库中常见的协议，5、为什么要使用协议** 5个方面结合自身的学习经验简单介绍一下这种“加强型protocol”的使用，入门级、属于学习总结，希望能给正在学习Swift的小伙伴们一点启发。

协议中定义属性和方法

协议为方法、属性、以及其他特定的任务需求或功能定义蓝图。协议可被类、结构体、或枚举类型采纳以提供所需功能的具体实现。满足了协议中需求的任意类型都叫做遵循了该协议。

Swift中定义一个协议和定义枚举、结构体或者类的格式类似，使用protocol关键字：

//定义一个名字为学生协议
protocol Student {
}

这里Student是使用**protocol **关键字声明的一个协议，和枚举、结构体、类命名原则相似，Student首字母大写表示在以后的使用中很可能会将Student看作是一个类型使用。

protocol Student {
    //定义一个可读可写的 name 属性
    var name: String { get set }
    //定义一个可读的 birthPlace 属性
    var birthPlace: String { get }
    //定义一个类属性 record
    static var qualification: String {get}
}

和定义方法一样，我们只需要确定该属性具体是什么类型并且添加对应的关键字，不需要具体的实现，更不能为他们赋上初始值（类似于计算属性）。定义好属性之后，我们就可以利用属性来做点事情了。

struct Puple: Student {
    static var qualification: String = "小学"
    var name: String
    var birthPlace: String = "北京"
}
var p1 = Puple(name: "小明", birthPlace: "上海")

定义一个Puple结构体遵循Student协议，该结构体中必须存在协议要求声明的三个属性matrikelnummer、name、birthPlace,static修饰的类型属性必须被有初始值或者存在get、set方法。对于普通的实例属性协议并不关心是计算型属性还是存储型属性。实例中的属性同样可以被修改：

var p1 = Puple(name: "小明", birthPlace: "上海")
Puple.qualification = "中学"

看到这里有的同学可能有些疑问，birthPlace、qualification明明只有get方法为什么却可以修改赋值呢？其实协议中的“只读”属性修饰的是协议这种“类型”的实例，例如下面的例子：

var s1: Student = p1
s1.birthPlace = "广州"

虽然我们并不能像创建类的实例那样直接创建协议的实例，但是我们可以通过“赋值”得到一个协议的实例。将p1的值赋值给Student类型的变量s1,修改s1的birthPlace属性时编译器就会报错：birthPlace是一个只读的属性，不能被修改。如果Puple中还存在Student没有的属性，那么在赋值过程中s1将不会存在这样的属性，尽管这样做的意义并不大，但是我们从中知道了协议中get、set的具体含义。

protocol Student {
    //类方法
    static func study()
    //实例方法
    func changeName()
}
struct CollageStudent: Student {
    //类方法实现
    static func study() {
    }
    //实例方法实现
    func changeName() {
    }
}
//方法的调用
CollageStudent.study()
var c1 = CollageStudent()
c1.changeName()

注意：当我们在结构体中的方法修改到属性的时候需要在方法前面加上关键字mutating表示该属性能够被修改（如果是类不需要添加mutating 关键字）,这样的方法叫做：异变方法，和 “在实例方法中修改值类型” 的处理是一样的。

protocol Student {
    mutating func changeName()
}
struct CollageStudent: Student {
    mutating func changeName() {
        self.name = "小明"
    }
}
var c1 = CollageStudent()
c1.changeName()

protocol Pet {
    init(name: String)
}
class Cat: Pet {
    var name: String = "Cat"
    required init(name: String) {
        self.name = name
    }
}

Cat由于遵循了Pet协议，应该用required关键字修饰初始化器的具体实现。
如果一个类既继承了某个类，而且遵循了一个或多个协议，我们应该将父类放在最前面，然后依次用逗号排列。

class SomeClass: OneProtocol, TwoProtocol {
}

这是因为Swift中类的继承是单一的，但是类可以遵守多个协议，因此为了突出其单一父类的特殊性，我们应该将继承的父类放在最前面，将遵守的协议依次放在后面。

protocol TextOne {
    func text() -> Int
}
protocol TextTwo {  
    func text() -> String
}

这两个协议中的text()方法名相同返回值不同，如果存在一个类型Person同时遵守了TextOne 和TextTwo，在Person实例调用方法的时候就会出现歧义。

struct Person: TextOne, TextTwo {
    func text() -> Int {
        return 10
    }
    func text() -> String { 
        return "hello"
    }
}

let p1 = Person()
//尝试调用返回值为Int的方法
let num = p1.text()
//尝试调用返回值为String的方法
let string = p1.text()

上面的调用肯定是无法通过的，因为编译器无法知道同名text()方法到底是哪个协议中的方法，那么出现这种情况的根本原因在于调用哪个协议的text()不确定，因此我们需要指定调用特定协议的text()方法，改进后的代码如下：

//尝试调用返回值为Int的方法
let num = (p1 as TextOne).text()
//尝试调用返回值为String的方法
let string = (p1 as TextTwo).text()

也可以理解为在进行调用前将p1常量进行类型转换。

协议的继承、聚合、关联类型

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

protocol OneProtocol {  
}
protocol TwoProtocol {
}
//定义一个继承子OneProtocol 和 TwoProtocol协议的新的协议: ThreeProtocol
protocol ThreeProtocol: OneProtocol, TwoProtocol {
}

如上所示，任何遵守了ThreeProtocol协议的类型都应该同时实现OneProtocol 和 TwoProtocol的要求必须实现的方法或属性。

//协议聚合成临时的类型
typealias Three = TwoProtocol & OneProtocol
//协议聚合成为参数的类型
func text(paramter: OneProtocol & TwoProtocol) {
}

一个很常见的例子：定义text函数的参数类型使用了协议的聚合，在这里我们并不关心paramter是什么类型的参数，只要它遵循这两个要求的协议即可。

struct Person: OneProtocol {
}
let p1 = Person()
if (p1 is OneProtocol){ //可以理解为：p1 是一个遵守了OneProtocol协议类型的实例
    print("yes")
}

如何让定义的协议只能被类遵守？：使用关键字class，该关键字修饰之后表示协议只能被类遵守，如果有枚举或结构体尝试遵守会报错。

//只能被类遵守的协议
protocol FourProtocol: class ,ThreeProtocol {
}
//此处报错
struct Person: FourProtocol {
}
class Perple: FourProtocol {
}

protocol WeightCalculable {
    //为weight 属性定义的类型别名
    associatedtype WeightType
    var weight: WeightType { get }
}

WeightCalculable是一个“可称重”协议，weight属性返回遵守该协议具体类型的实例的重量。这里我们使用associatedtype为该属性的类型定义了一个别名WeightType，换言之在WeightCalculable中并不关心weight的类型是Int 还是Double或者是其他类型,他只是简单的告诉我们返回的类型是WeightType，至于WeightType到底是什么类型由遵守该协议的类中自己去定义。那么这样做的好处是什么呢？

//定义手机结构体
struct MobilePhone: WeightCalculable {
    typealias WeightType = Double
    var weight: WeightType
}
let iPhone7 = MobilePhone(weight: 0.138)
//定义汽车结构体
struct Car: WeightCalculable {
    typealias WeightType = Int
    var weight: WeightType
}
let truck = Car(weight: 3000_000)

如上所示：MobilePhone、Car类型都遵守了WeightCalculable协议，都能被称重，但是手机由于结构精密、体型小巧，小数点后面的数字对于称重来说是必不可少的，所以使用了Double类型，返回0.138千克即138克，但是对于汽车这样的庞然大物在称重时如果还计较小数点后面的数字就显得没有意义了，所以使用Int类型，表示3000千克也就是3吨。
从上面的例子可以很好的看出由于MobilePhone、Car称重时逻辑是一样的，但是对于weight属性的返回值要求不一样，如果仅仅因为返回值类型的不同定义两个类似的协议一个是Int类型另外一个是Double类型，这样做显然是重复的、不合适的。所以associatedtype在这种情况下就发挥出作用了，他让开发者在遵守协议时根据需求去定义返回值的类型，而不是在协议中写死。唯一要注意的是：一定要在遵守该协议的类型中使用typealias规定具体的类型。不然编译器就报错了。

协议的扩展

协议的扩展是协议中很重要的一部分内容，主要体现在以下两个方面：

protocol Score {
    var math: Int { get set}
    var english: Int {get set}
    func mathPercent() -> Double
}

首先定义一个Score协议，里面有两个Int类型的属性math、english和一个计算数学所占分数的比例的方法mathPercent。

struct Puple: Score {
    var math: Int
    var english: Int
    func mathPercent() -> Double {
        return Double(math) / Double(math + english)
    }
}

定义Puple遵守该协议，实现了必要的属性和方法。

let p1 = Puple(math: 90, english: 80)
s1.mathPercent()

通过上面的代码可以计算出s1中数学所占的比例，但是设想一下如果还有很多个类似Puple结构体的类型都需要遵守该协议，都需要默认实现mathPercent 方法计算出自己的数学分数所占的比例，还是按照上面的写法代码量就很大而且很冗杂了。问题的关键在于：任何遵守Score协议类型的mathPercent计算逻辑是不变的，而且需要默认实现。那么我们如何轻松的实现这样的效果呢，答案是：为Score添加方法的扩展。

extension Score {
    func mathPercent() -> Double {
        return Double(math) / Double(math + english)
    }
}

将mathPercent的具体实现写在协议的扩展里面，就能为所有的遵守Score的类型提供mathPercent默认的实现。

struct CollageStudent: Score {
    var math: Int
    var english: Int
}
let c1 = CollageStudent(math: 80, english: 80)
c1.mathPercent()

如此就能起到“不实现mathPercent方法也能计算出数学所占分数的比例”的效果了。此语法在Swift中有一个专业术语叫做：default implementation 即默认实现。包括计算属性和方法的默认实现，但是不支持存储属性，如果遵循类型给这个协议的要求提供了它自己的实现，那么它就会替代扩展中提供的默认实现。
通过这样的语法，我们不仅能为自定义的协议提供扩展，还能为系统提供的协议添加扩展，例如，为CustomStringConvertible添加一个计算属性默认实现的扩展：

extension CustomStringConvertible {
    var customDescription: String {
        return "YQ" + description
    }
}

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

简单的来说我们可以对存在的类型（尤其是系统的类型）添加协议遵守。尽管这更像是对“类型的扩展”，但是官方文档将这部分放在了协议的扩展中。

extension Double : CustomStringConvertible {
    /// A textual representation of the value.
    public var description: String { get }
}

上面的代码就是Swift标准库中对于Double类型添加的一个协议遵守。除了添加系统协议的遵守，我们还可以添加自定义的协议的遵守，其方法都是一样的，这里就不太赘述了。

Swift标准库中常见的协议

学习完协议的基础语法，我们大致熟悉一下Swift标准库中提供的协议。


55个标准库协议

Swift标准库为我们提供了55种协议，他们的命名很有特点，基本是以"Type"、“able”、“Convertible” 结尾，分别表示该协议“可以被当做XX类型”、“具备某种能力或特性”、“能够进行改变或变换”。因此在自定义协议时应该尽可能遵守苹果的命名规则，便于开发人员之间的高效合作。下面介绍一下常见的几种协议：

struct Student: Equatable {
    var math: Int
    var english: Int
}
//重载 == 运算符
func == (s1: Student, s2: Student) -> Bool {
    return s1.math == s2.math && s1.english == s2.english
}

Student遵守Equatable并且重载了==运算符后就能直接比较两个学生的成绩是否相等了。

let s1 = Student(math: 80, english: 60)
let s2 = Student(math: 70, english: 90)
s1 == s2 //false

值得注意的是，由于重载==运算符是遵守Equatable协议后要求我们实现的，因此重载方法应该紧跟在遵守该协议的类型定义后，中间不能有其他的代码，否则就报错了。

struct Student: Comparable{
    var math: Int
    var english: Int
}
//重载 < 运算符
func < (s1: Student, s2: Student) -> Bool {
    return (s1.math + s1.english) < (s2.math + s2.english)
}
let s1 = Student(math: 80, english: 60)
let s2 = Student(math: 70, english: 90)
s1 < s2 //true

struct Student: CustomStringConvertible{
    var math: Int
    var english: Int
    var description: String {
        return "Your math:" + String(math) + ", english:" + String(english)
    }
}
let s1 = Student(math: 80, english: 60)
print(s1) // Your math:80, english:60

struct Person: ExpressibleByArrayLiteral {
    var name: String = ""
    var job: String = ""
    typealias Element = String
    init(arrayLiteral elements: Person.Element...) {  
        if elements.count == 2 {
            name = elements[0]
            job = elements[1]
        }
    }
}
let p1: Person = ["jack", "teacher"]
print(p1.name) //jack
print(p1.job) //teacher

上面的代码用到了之前关联类型，通过遵守ExpressibleByArrayLiteral，现在的Person就可以使用数组直接创建实例了。

类似的协议还有：
ExpressibleByDictionaryLiteral、ExpressibleByStringLiteral、ExpressibleByBooleanLiteral 、ExpressibleByIntegerLiteral等等，相信大家通过名称就能大概猜出具体作用，由于篇幅有限这里就不再赘述了。

为什么要使用协议

1，在函数、方法或者初始化器里作为形式参数类型或者返回类型；

2，作为常量、变量或者属性的类型；
3，作为数组、字典或者其他存储器的元素的类型。

文章最后

以上就是本人关于协议语法的心得，示例代码在Swift3.0语法下都是编译通过的，知识点比较杂，部分描述引自官方的文档，另外协议作为一种强大的语法肯定还有很多值得我们去探索，本文列出的知识点仅仅涵括了部分内容。如果文中有任何纰漏或错误欢迎在评论区留言指出，本人将在第一时间修改过来；喜欢我的文章，可以关注我以此促进交流学习； 如果觉得此文戳中了你的G点请随手点赞；转载请注明出处，谢谢支持。

上一篇下一篇

猜你喜欢

热点阅读