在Swift中协议不仅可以定义方法和属性，而且协议是可以扩展的，最关键的是，在协议的扩展中可以添加一些方法的默认实现，就是在协议的方法中可以实现一些逻辑，由于这个特性，Swift是可以面向协议进行编程的。
扩展协议和默认实现
protocol Record {
var wins: Int{get}
var losses:Int{get}
func winningPercent() -> Double
}
struct BasketballRecord:Record,CustomStringConvertible {
var wins: Int
var losses: Int
func winningPercent() -> Double {
return Double(wins)/Double(wins + losses)
}
var description: String {
return String.init(format: "WINS: %d, LOSSES: %d", [wins,losses])
}
}
struct baseballRecord:Record,CustomStringConvertible {
var wins: Int
var losses: Int
func winningPercent() -> Double {
return Double(wins)/Double(wins + losses)
}
var description: String {
return String.init(format: "WINS: %d, LOSSES: %d", [wins,losses])
}
}
let teamRecord = BasketballRecord(wins: , losses: )
print(teamRecord)
let baseball = baseballRecord(wins: , losses: )
print(baseball)
我们可以看到 这两个结构体 都分别继承了Record 和 CustomStringConvertible协议 其中第一个是我们自定义的协议 第二个是系统协议，在Swift中协议也是可以继承的，于是我们可以改写成下面的模式。
protocol Record:CustomStringConvertible {
var wins: Int{get}
var losses:Int{get}
func winningPercent() -> Double
}
struct BasketballRecord:Record {
var wins: Int
var losses: Int
func winningPercent() -> Double {
return Double(wins)/Double(wins + losses)
}
var description: String {
return String.init(format: "WINS: %d, LOSSES: %d", [wins,losses])
}
}
struct baseballRecord:Record {
var wins: Int
var losses: Int
func winningPercent() -> Double {
return Double(wins)/Double(wins + losses)
}
var description: String {
return String.init(format: "WINS: %d, LOSSES: %d", [wins,losses])
}
}
你会看到还是有冗余的代码 就是遵守CustomStringConvertible协议 实现的description的返回时一样的，这个时候我们就像进一步封装，那么我们该怎么做呢？这个其实就用到我们所说：协议是可以扩展的，而且在扩展中协议的属性和方法是可以有默认实现的，我们可以这样写：
protocol Record:CustomStringConvertible {
var wins: Int{get}
var losses:Int{get}
func winningPercent() -> Double
}
//扩展协议
extension Record {
var description: String {
return String.init(format: "WINS: %d, LOSSES: %d", [wins,losses])
}
}
struct BasketballRecord:Record {
var wins: Int
var losses: Int
func winningPercent() -> Double {
return Double(wins)/Double(wins + losses)
}
}
struct baseballRecord:Record {
var wins: Int
var losses: Int
func winningPercent() -> Double {
return Double(wins)/Double(wins + losses)
}
}
这样写是不是就方便多了呢，但是仔细观察 我们在遵守协议的各个结构体中是不是还有逻辑类似，但是写了好几遍的代码呢，我们是不是也可以考虑，将计算胜率的方法也迁移到扩展中呢？
protocol Record:CustomStringConvertible {
var wins: Int {get}
var losses:Int {get}
}
//扩展协议
extension Record {
var description: String {
return String.init(format: "wins: %d, losses:%d", [wins,losses])
}
var gamePlayed:Int {
return wins + losses
}
func winningPercent() -> Double {
return Double(wins)/Double(gamePlayed)
}
}
struct BasketballRecord:Record {
var wins: Int
var losses: Int
}
struct baseballRecord:Record {
var wins: Int
var losses: Int
}
是不是更加简便了呢，那么假如一场比赛既有输赢，又有打平的时候呢，我们新增加一个协议，当遵守了不同的协议，他们执行的默认方法，就是既满足了有输赢又可以打平里面扩展的方法的默认实现，如果只遵守了一个Record协议，则执行扩展Record中的默认实现。
protocol Record:CustomStringConvertible {
var wins: Int {get}
var losses:Int {get}
}
//打平的协议
protocol Tieable {
var ties:Int {get set}
}
//扩展即遵守了Record协议的又遵守了Tieable协议
extension Record where Self:Tieable {
var gamePlayed:Int {
return wins + losses + ties
}
func winningPercent() -> Double {
return Double(wins)/Double(gamePlayed)
}
}
//扩展协议
extension Record {
var description: String {
return String.init(format: "wins: %d, losses:%d", [wins,losses])
}
var gamePlayed:Int {
return wins + losses
}
func winningPercent() -> Double {
return Double(wins)/Double(gamePlayed)
}
}
struct BasketballRecord:Record {
var wins: Int
var losses: Int
}
struct baseballRecord:Record {
var wins: Int
var losses: Int
}
//可以平局的
struct FootBallRecord:Record,Tieable {
var wins: Int
var losses: Int
var ties: Int
}
协议聚合
语法结构
协议1 & 协议2
示例代码
//判断是否可以获得奖励的协议
protocol Prizable {
func isPrizable() -> Bool
} func award(prizable: Prizable & CustomStringConvertible){
if prizable.isPrizable() {
print(prizable)
print("你可以获奖")
}else{
print("您不可以获奖")
}
}
表示这个函数的参数 即遵守Prizable协议，也遵守了CustomStringConvertible的协议。
泛型约束
struct Student:CustomStringConvertible,Equatable,Comparable,Prizable{
var name:String
var score:Int
var description: String {
return name
}
func isPrizable() -> Bool {
return score >
}
}
func == (s1:Student,s2:Student)->Bool {
return s1.score == s2.score
}
func < (s1:Student,s2:Student) ->Bool {
return s1.score < s2.score
}
let tian = Student(name: "tian", score: )
let a = Student(name: "Alice", score: )
let b = Student(name: "Bob", score: )
let c = Student(name: "Karl", score: )
let students = [a,b,c,tian]
//报错 原因是因为Comparable 这个协议的实现中自己调用了自己 此时这种协议不能当作一种类型 在这种情况下我们可以改为下面的代码
func topOne(seq:[Comparable]) ->Comparable {
}
为了解决上面的错误，我们可以这样写
struct Student:CustomStringConvertible,Equatable,Comparable,Prizable{
var name:String
var score:Int
var description: String {
return name
}
func isPrizable() -> Bool {
return score >
}
}
func == (s1:Student,s2:Student)->Bool {
return s1.score == s2.score
}
func < (s1:Student,s2:Student) ->Bool {
return s1.score < s2.score
}
let tian = Student(name: "tian", score: )
let a = Student(name: "Alice", score: )
let b = Student(name: "Bob", score: )
let c = Student(name: "Karl", score: )
let students = [a,b,c,tian]
func topOne<T:Comparable>(seq:[T]) ->T {
assert(seq.count > )
return seq.reduce(seq[]){
max($, $)
}
}
topOne(seq: [,,,])
func topPrizableOne<T:Comparable & Prizable>(seq:[T]) ->T? {
return seq.reduce(nil) {
(tempTop:T?,contender:T) in
guard contender.isPrizable() else {
return tempTop
}
guard let tempTop = tempTop else {
return contender
}
return max(tempTop, contender)
}
}
topPrizableOne(seq: students)?.name