Swift 学习笔记(面向协议编程)
在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
Swift 学习笔记(面向协议编程)的更多相关文章
- Spring学习笔记--面向切面编程(AOP)
什么是AOP AOP(Aspect Oriented Programming),意为面向切面编程,通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术.AOP是OOP的延续,是软件开发中的 ...
- swift学习笔记之-协议
//协议(Protocols) import UIKit /*协议(Protocols) 1.协议定义了一个蓝图,规定了用来实现某一特定任务或者功能的方法.属性,以及其他需要的东西 2.类.结构体或枚 ...
- 为什么说swift是面向协议编程--草稿
为什么说swift是面向协议编程 public protocol ReactiveCompatible { /// Extended type associatedtype CompatibleTyp ...
- Swift -POP( 面向协议编程)与OOP(面向对象编程)
面向协议编程(Protocol Oriented Programming,简称POP),是Swift的一种编程范式,Apple于2015年WWDC提出的,如果大家看Swift的标准库,就会看到大量PO ...
- fir.im Weekly - 揭秘 iOS 面向协议编程
本期 fir.im Weekly 重点推荐关于 iOS 面向协议编程相关文章,还有 iOS 多线程安全.Swift 进阶.Android MVVM 应用框架.Android 蓝牙实践等技术文章分享和工 ...
- 孙鑫VC学习笔记:多线程编程
孙鑫VC学习笔记:多线程编程 SkySeraph Dec 11st 2010 HQU Email:zgzhaobo@gmail.com QQ:452728574 Latest Modified ...
- WCF学习笔记之事务编程
WCF学习笔记之事务编程 一:WCF事务设置 事务提供一种机制将一个活动涉及的所有操作纳入到一个不可分割的执行单元: WCF通过System.ServiceModel.TransactionFlowA ...
- Spring实战第四章学习笔记————面向切面的Spring
Spring实战第四章学习笔记----面向切面的Spring 什么是面向切面的编程 我们把影响应用多处的功能描述为横切关注点.比如安全就是一个横切关注点,应用中许多方法都会涉及安全规则.而切面可以帮我 ...
- 编程范式 --- 面向协议编程(Protocol Oriented Programming,简称POP)
面向协议编程(Protocol Oriented Programming,简称POP) 是Swift的一种编程范式,Apple于2015年WWDC踢出 在Swift的标准库中,能见到大量POP的影子 ...
随机推荐
- codevs——1010 过河卒(棋盘DP)
2002年NOIP全国联赛普及组 时间限制: 1 s 空间限制: 128000 KB 题目等级 : 黄金 Gold 题解 查看运行结果 题目描述 Description 如图,A 点有 ...
- centos 7 mysql 离线安装教程
1. 解压下载的zip包,会发现有以下几个rpm包: MySQL-client-advanced-5.6.22-1.el7.x86_64.rpm MySQL-devel-advanced-5.6.22 ...
- 聊聊、Zookeeper Windows启动
Apache ZooKeeper is an effort to develop and maintain an open-source server which enables highly rel ...
- Using Single Alert For Messages And Confirmation Messages In Oracle Forms With Set_Alert_Button_Property
Learn how to use single Oracle Form's Alert object for warning/information messages and confirmation ...
- The web application [/struts2_0100] created a ThreadLocal with key of type
引用: 严重: The web application [/struts2_0100] created a ThreadLocal with key of type [com.opensymphony ...
- mac 安装 office
1.下载word2016,可以网上搜一下,很多资源 当然这里将我用的版本提供给你: 链接: https://pan.baidu.com/s/1mix07lY 密码: asgc 一直默认下一步进行安 ...
- SilverLight-DataBinding-DataTemplates: 三、数据绑定 DataTemplates模板的使用(求助,没有到达实例效果,求高人指点迷津)
ylbtech-SilverLight-DataBinding-DataTemplates: 三.数据绑定 DataTemplates模板的使用 1.A, Data Templates Intro(数 ...
- struts2.16中文乱码问题解决
方法1.在struts.xml文件中添加<constant name="struts.i18n.encoding" value="GBK" /> 方 ...
- 【AngularJS】【01】简介
※文件引自OneDrive,有些人可能看不到
- 关于使用Axure RP进行原型开发的一些心得体会
Axure RP(Axure Rapid Prototyping)是一款高速实现.准确表达.带有交互效果且易于上手的原型设计工具. 本人在曾參与某系统需求分析时開始接触Axure RP,初步掌握了一定 ...