iOS --- 面向协议的编程（swift2.3）

最新推荐文章于 2019-01-31 11:32:49 发布
最新推荐文章于 2019-01-31 11:32:49 发布
阅读量2.5k 收藏
点赞数 1
分类专栏： iOS 日常学习笔记 iOS 记录生活的点点滴滴 文章标签： ios 编程 swift 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yhy1271927580/article/details/51820678
版权

iOS — 面向协议的编程（swift）

下面简单的介绍面向协议的编程的应用

  1. 扩展协议和默认实现

  2. 面向协议编程

  3. 协议聚合

  4. 泛型约束

  5. swift是面向协议的编程语言

  6. UIKit中的委托模式

  7. 创建自己的委托模式

  8. 可选的协议方法

一：扩展协议和默认实现

protocol Record: CustomStringConvertible{

    var wins: Int {get}
    var losses: Int {get}

    func winningPercent() -> Double
}


// 扩展一个协议的时候，可以拥有实现！，那么就是说，虽然协议不能够实现属性和方法，但是在协议的扩展里面可以实现属性和方法
extension Record{
    //那么遵守CustomStringConvertible协议必须实现的属性就可以写在协议的扩展里面，那么结构体和类中就可以不写，打印出来的结果就是自定义的格式
    //这个例子就是告诉我们，在协议的扩展中，可以实现属性和函数的逻辑，在类和结构中就不需要实现了
    var description: String{
        return String(format: "WINS: %d , LOSSES: %d", arguments: [wins,losses])
    }

    func shoutWins(){
        print("WE WIN",wins,"TIMES!!!")
    }

    var gamePlayed: Int{
        return wins + losses
    }
}


struct BasketballRecord: Record{

    var wins: Int
    var losses: Int

    func winningPercent() -> Double {
        //return Double(wins)/Double(wins + losses)
        return Double(wins)/Double(gamePlayed)
    }
}
//extension BasketballRecord: CustomStringConvertible{}


struct BaseballRecord: Record{

    var wins: Int
    var losses: Int

    func winningPercent() -> Double {
        return Double(wins)/Double(gamePlayed)
    }
}

let teamRecord = BasketballRecord(wins: 2, losses: 10)
print(teamRecord)

teamRecord.shoutWins()


// 扩展标准库中的协议
extension CustomStringConvertible{
    var descriptionWithDate: String{
        return NSDate().description + " " + description
    }
}

print( teamRecord.descriptionWithDate )
二：面向协议编程
protocol Record: CustomStringConvertible{

    var wins: Int {get}
    var losses: Int {get}

    //func winningPercent() -> Double
}

extension Record{

    var description: String{
        return String(format: "WINS: %d , LOSSES: %d", arguments: [wins,losses])
    }

    var gamePlayed: Int{
        return wins + losses
    }
}

protocol Tieable{
    var ties: Int{get set}
}

//由于有些比赛没有平局，那么我只想给有平局的结构和类增加一个协议的扩张，用where关键字，表示如果这个类或者结构遵守了Tieable协议的话，我就给他扩展这个平局的属性，然后再将gamePlayed和winningPercent的实施细则重写，覆盖在协议中默认的内容，那么如果，我们类或结构遵守了Tieable这个协议的话，我们就可以直接使用这个被覆盖的gamePlayed属性和winningPercent方法了
extension Record where Self: Tieable{

    var gamePlayed: Int{
        return wins + losses + ties
    }

    func winningPercent() -> Double {
        return Double(wins)/Double(wins + losses + ties)
    }
}


struct BasketballRecord: Record{

    var wins: Int
    var losses: Int

//    func winningPercent() -> Double {
//        return Double(wins)/Double(gamePlayed)
//    }
}

//由于在Record协议里面有一个默认的gamePlayed属性实现过程，但是在我们的具体的结构和类中，可以重写这个属性的实现，也就是可以覆盖协议扩展中属性的实现过程
struct BaseballRecord: Record{

    var wins: Int
    var losses: Int
    let gamePlayed = 162

//    func winningPercent() -> Double {
//        return Double(wins)/Double(gamePlayed)
//    }
}


struct FootballRecord: Record, Tieable{
    var wins: Int
    var losses: Int
    var ties: Int

//    var gamePlayed: Int{
//        return wins + losses + ties
//    }
//
//    func winningPercent() -> Double {
//        return Double(wins)/Double(wins+losses+ties)
//    }
}


let basketballTeamRecord = BasketballRecord(wins: 2, losses: 10)
let baseballTeamRecord = BaseballRecord(wins: 10, losses: 5)

basketballTeamRecord.gamePlayed
baseballTeamRecord.gamePlayed

let footballTeamRecord = FootballRecord(wins: 1, losses: 1, ties: 1)
footballTeamRecord.gamePlayed
footballTeamRecord.winningPercent()
三：协议聚合
protocol Record: CustomStringConvertible{

    var wins: Int {get}
    var losses: Int {get}
}

extension Record{

    var description: String{
        return String(format: "WINS: %d , LOSSES: %d", arguments: [wins,losses])
    }

    var gamePlayed: Int{
        return wins + losses
    }

    func winningPercent() -> Double {
        return Double(wins)/Double(gamePlayed)
    }
}

protocol Tieable {
    var ties: Int {get set}
}

extension Record where Self: Tieable{

    var gamePlayed: Int{
        return wins + losses + ties
    }

    func winningPercent() -> Double {
        return Double(wins)/Double(wins + losses + ties)
    }
}

protocol Prizable{

    func isPrizable() -> Bool
}


struct BasketballRecord: Record, Prizable{

    var wins: Int
    var losses: Int

    func isPrizable() -> Bool{
        return wins > 2
    }
}

struct BaseballRecord: Record, Prizable{

    var wins: Int
    var losses: Int
    let gamePlayed = 162

    func isPrizable() -> Bool{
        return gamePlayed > 10 && winningPercent() >= 0.5
    }
}

struct FootballRecord: Record, Tieable, Prizable{
    var wins: Int
    var losses: Int
    var ties: Int

    func isPrizable() -> Bool{
        return wins > 1
    }
}


var basketballTeamRecord = BasketballRecord(wins: 2, losses: 10)
var baseballTeamRecord = BaseballRecord(wins: 10, losses: 5)
var footballTeamRecord = FootballRecord(wins: 1, losses: 1, ties: 1)

//这里表面传递进来的one不仅要遵守Prizable协议还要遵守CustomStringConvertible协议
func award(one: protocol<CustomStringConvertible, Prizable>){

    if one.isPrizable(){
        print(one)
        print("Congratulation! You won a prize!")
    }
    else{
        print(one)
        print("You can not have the prize!")
    }
}

award(baseballTeamRecord)


struct Student: CustomStringConvertible, Prizable{//description是CustomStringConvertible必须实现的属性
    var name: String
    var score: Int
    var description: String{
        return name
    }

    func isPrizable() -> Bool {
        return score >= 60
    }
}

let liuyubobobo = Student(name: "liuyubobobo", score: 100)
award(liuyubobobo)
四：泛型约束
protocol Prizable{
    func isPrizable() -> Bool
}

struct Student: CustomStringConvertible, Equatable, Comparable, Prizable{
    var name: String
    var score: Int
    var description: String{
        return name + "Score: " + String(score)
    }

    func isPrizable() -> Bool {
        return score >= 60
    }
}
func ==(s1:Student,s2:Student) -> Bool{ return s1.score == s2.score}
func <(s1:Student,s2:Student) -> Bool{ return s1.score < s2.score}

let liuyubobobo = Student(name: "liuyubobobo", score: 100)

let a = Student(name: "Alice", score: 80)
let b = Student(name: "Bob", score: 92)
let c = Student(name: "Karl", score: 85)

let students = [a, b, c, liuyubobobo]


//func topOne(seq:[Comparable]) -> Comparable
//让大写的遵守Comparable协议，让数组元素的类型为T，<T: Comparable>就是泛型的约束，，
func topOne<T: Comparable>(seq:[T]) -> T{
    assert(seq.count > 0)
    //如果使数组中的元素压缩成一个元素，使用结尾闭包
    return seq.reduce(seq[0]){ max( $0 , $1 ) }
}

topOne([4,5,7,2])
topOne(["Hello","Swift"])
topOne([a,b,c,liuyubobobo])

//让大写的遵守Comparable协议，让数组元素的类型为T，<T: protocol<Comparable, Prizable>>就是协议聚合的泛型约束，，
func topPrizableOne<T: protocol<Comparable, Prizable>>(seq:[T]) -> T?{
    return seq.reduce(nil){ ( tmpTop: T? , contender: T) in

        guard contender.isPrizable() else{
            return tmpTop
        }

        guard let tmpTop = tmpTop else{
            return contender
        }

        return max( tmpTop , contender )
   }
}

topPrizableOne(students)?.name
五：swift是面向协议的编程语言
/**
 根据swift语言中标准库的统计：
Classes: 6 个

Enum: 8 个

Structs: 103 个

Protocol： 86 个

 */

var a: Int = 3

var arr: Array<Int> = [1,2,3]
六：UIKit中的委托模式
这个例子用uitableview引出
七：创建自己的委托模式

protocol TurnBasedGameDelegate{

    func gameStart()
    func playerMove()
    func gameEnd()

    func gameOver() -> Bool
}

protocol TurnBasedGame{

    var turn: Int{get set}

    func play()
}

//这个类完成了整个游戏的过程，但是不知道游戏的细节部分，那么在具体的玩这个游戏的时候，我们就不要担心这个游戏到底是怎么一个过程，只是说明这个游戏怎么玩就是了
class SinglePlayerTurnBasedGame: TurnBasedGame{

    var delegate:TurnBasedGameDelegate!
    var turn = 0

    func play(){

        delegate.gameStart()//游戏开始
        while !delegate.gameOver() {//知道什么时候结束
            print("ROUND",turn,":")
            delegate.playerMove()//玩家开始动作
            turn += 1
        }
        delegate.gameEnd()
    }
}

class RollNumberGame: SinglePlayerTurnBasedGame, TurnBasedGameDelegate{

    var score = 0

    override init() {
        super.init()//先调用父类的构造函数，初始化父类的属性
        delegate = self//再初始化自己属性
    }

    func gameStart() {

        score = 0
        turn = 0

        print("Welcome to Roll Number Game.")
        print("Try to use least turn to make total 100 scores!")
    }

    func playerMove() {
        let rollNumber = Int(arc4random())%6 + 1
        score += rollNumber
        print("You rolled a" , rollNumber , "! The score is",score,"now!")
    }

    func gameEnd() {
        print("Congratulation! You win the game in" , turn , "ROUND!")
    }

    func gameOver() -> Bool{
        return score >= 30
    }
}


let rollingNumber = RollNumberGame()
rollingNumber.play()



class RockPaperScissors: SinglePlayerTurnBasedGame, TurnBasedGameDelegate{

    enum Shape: Int, CustomStringConvertible{
        case Rock
        case Scissors
        case Papper

        func beat(shape: Shape) -> Bool{
            return (self.rawValue + 1)%3 == shape.rawValue
        }

        var description: String{

            switch(self){
            case .Papper:   return "Paper"
            case .Rock:     return "Rock"
            case .Scissors: return "Scissors"
            }
        }
    }

    var wins = 0
    var otherWins = 0

    override init() {
        super.init()
        delegate = self
    }

    static func go() -> Shape{
        return Shape(rawValue: Int(arc4random())%3)!
    }

    func gameStart() {
        wins = 0
        otherWins = 0
        print("== Rock Paper Scissor ==")
    }

    func gameOver() -> Bool {
        //return turn >= 3
        return wins >= 2 || otherWins >= 2
    }

    func gameEnd() {
        if( wins >= 2 ){
            print("YOU WIN!")
        }
        else{
            print("YOU LOSE...")
        }
    }

    func playerMove() {

        let yourShape = RockPaperScissors.go()
        let otherShape = RockPaperScissors.go()
        print("Your:",yourShape)
        print("Other:",otherShape)

        if yourShape.beat(otherShape){
            print("You win this round")
            wins += 1
        }
        else if otherShape.beat(yourShape){
            print("You lose this round")
            otherWins += 1
        }
        else{
            print("Tie in this round")
        }
    }

}

let rockPaperScissors = RockPaperScissors()
rockPaperScissors.play()
八：可选的协议方法
//如果协议中有可选型的方法，那么在协议前必须加上@objc关键字，那么这个协议就能被OC语言应用
@objc protocol TurnBasedGameDelegate{

    func gameStart()
    func playerMove()
    func gameEnd()

    optional func turnStart()
    optional func turnEnd()

    func gameOver() -> Bool
}

protocol TurnBasedGame{

    var turn: Int{get set}

    func play()
}
//那么这个父类也要继承object-c
class SinglePlayerTurnBasedGame: NSObject, TurnBasedGame{

    var delegate:TurnBasedGameDelegate!
    var turn = 0

    func play(){

        delegate.gameStart()
        while !delegate.gameOver() {
            //如果一个函数是可选型的函数，那么这个函数就要解包
            if let turnStart = delegate.turnStart{
                turnStart()
            }
            else{
                print("Round",turn,":")
            }

            delegate.playerMove()

            //这里也需要解包，如果解包成功了就调用这个函数，如果解包失败就什么事也不做
            delegate.turnEnd?()

            turn += 1
        }
        delegate.gameEnd()
    }
}


class RockPaperScissors: SinglePlayerTurnBasedGame, TurnBasedGameDelegate{

    enum Shape: Int, CustomStringConvertible{
        case Rock
        case Scissors
        case Papper

        func beat(shape: Shape) -> Bool{
            return (self.rawValue + 1)%3 == shape.rawValue
        }

        var description: String{

            switch(self){
            case .Papper:   return "Paper"
            case .Rock:     return "Rock"
            case .Scissors: return "Scissors"
            }
        }
    }

    var wins = 0
    var otherWins = 0

    override init() {
        super.init()
        delegate = self
    }

    static func go() -> Shape{
        return Shape(rawValue: Int(arc4random())%3)!
    }

    @objc func gameStart() {//
        wins = 0
        otherWins = 0
        print("== Rock Paper Scissor ==")
    }

    func gameOver() -> Bool {
        return wins >= 2 || otherWins >= 2
    }

    func gameEnd() {
        if( wins >= 2 ){
            print("YOU WIN!")
        }
        else{
            print("YOU LOSE...")
        }
    }

    func playerMove() {

        let yourShape = RockPaperScissors.go()
        let otherShape = RockPaperScissors.go()
        print("Your:",yourShape)
        print("Other:",otherShape)

        if yourShape.beat(otherShape){
            print("You win this round")
            wins += 1
        }
        else if otherShape.beat(yourShape){
            print("You lose this round")
            otherWins += 1
        }
        else{
            print("Tie in this round")
        }
    }

    func turnStart() {
        print("*** ROUND START ***")
    }

    func turnEnd(){
        print("*******************")
    }

}

let rockPaperScissors = RockPaperScissors()
rockPaperScissors.play()
尹欢一
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
iOS开发进阶（三）：协议（Protocol）讲解
IT全栈 华强工作室
11-23 4万+
Objective-C中协议的概念与Java中接口的概念并不完全相同，即一个类可以在不声明它匹配某个协议的情况下，实现这个协议所包含的方法，也即实质上匹配这个协议，而这种差别对外部代码而言是不可见的。正式协议的声明不提供实现，它只是简单地表明匹配该协议的类实现了该协议的方法，保证调用端可以安全调用方法。这是一个协议的例子，多线程编程中经常要确保一份共享资源同时只有一个线程可以使用，会在使用前给该资源挂上锁 ，以上即为一个表明有"锁"的概念的协议，协议中有两个方法，只有名称但尚未实现。
iOS开发：面向协议编程与 Cocoa 的邂逅 (下)
jijiji000111的专栏
12-06 906
喵神原文地址：https://onevcat.com/2016/12/pop-cocoa-2/ 本文是笔者在 MDCC 16 (移动开发者大会) 上 iOS 专场中的主题演讲的文字整理。您可以在这里找到演讲使用的 Keynote，部分示例代码可以在 MDCC 2016 的官方 repo 中找到。 在上半部分主要介绍了一些理论方面的内容，包括面向对象编程存在的问题，面向协议的
iOS开发峰会：Swift面向协议编程与Cocoa框架的邂逅
10-21
由CSDN、创新工场联合主办的MDCC 移动开发者大会（Mobile Developer Conference China），已于2016年9月23日-24日在北京·国家会议中心举办。大会以移动领域热点技术+典型应用案例实战为主的内容主旨，增设移动直播、VR开发等热点技术实战专场，满足移动开发者的新需求，以促进移动开发领域的分享和交流。
ios面向协议开发与继承。
KEELON的博客
03-08 1243
面向对象开发在讲解面向协议开发的之前，我们来探讨一个面向对象发，封装继承多态，这是一个面向对象开发的特点。当我们的很多类都会使用同一种方法的时候，我们可能会想到抽取一个父类，这个就是我们常见的继承。import UIKitclass BaseView: UIView {}extension BaseView{        class func loadFromeNib()-&gt;BaseVie...
ios-swift:ios-swift
07-11
本项目"ios-swift:ios-swift"由Guilherme Silveira创建，旨在提供Swift编程的基础知识和实践，帮助开发者入门iOS应用开发。 Swift的特点包括简洁的语法、安全性、高性能以及与Objective-C的无缝集成。在"ios-swift-...
ios-mvp-swift:iOS MVP架构
05-23
mvp-迅捷使用Swift 3的iOS MVP体系结构的示例项目。PODS 在此示例项目中，包括一些适用于iOS的有用的pod，例如： ：Swift中优雅的HTTP网络 ：在Swift中处理JSON数据的更好方法样本API 该项目使用“示例API链接，资源...
iOS-Swift-GoogleDriveSample
06-13
iOS-Swift-GoogleDriveSample 这是一个集成 Google Drive API for iOS 的示例。 里面实现的方法是提供另一种集成Google API的方案。 有关更多信息，请查看我在 WordPress 中的帖子。
ios-swift-objc英文打包
06-13
The Notes for Professionals book is compiled from Stack Overflow Documentation, the content is written by the beautiful people at Stack Overflow. Text content is released under Creative Commons BY-SA....
Learn-iOS-Swift-by-Examples 案例资源
最新发布
05-13
Swift是一门现代、高效且多...多范式：Swift支持面向对象编程、函数式编程和协议导向编程等多种编程范式，使得代码更灵活且易于扩展。其中，Swift的函数式编程支持包括高阶函数、闭包等特性，使得编程更加灵活和简洁。
面向协议编程
12-21
用面向协议方式编程，让项目代码更加的解偶，更加的容易维护
泛型协议：我必须承认面向协议的编程不是灵丹妙药。 它当然很有用，但是您会发现Swift协议的陷阱。 但是，您最终将使用大脑解决问题
02-18
泛型协议：我必须承认面向协议的编程不是灵丹妙药。 它当然很有用，但是您会发现Swift协议的陷阱。 但是，您最终将使用大脑解决问题
IOS---------Controller瘦身二：面向协议编程MVP模式，对M和V进行解耦
码农--xc
01-31 1055
前言：  续上一篇https://blog.csdn.net/qq_33226881/article/details/86635136写如何封装UITableView的数据源和代理源以达到对C瘦身以及解耦目的后，又一篇对C瘦身以及解耦的文章，大家可整合两篇进行使用，基本可以使C变得好看很多，不显得辣么臃肿。   MVP设计模式： 1、数据请求放于M里面 2、新增一个modelPresen...
iOS-Swift 面向协议编程/组件化(模块化)编程思想
极客学伟的技术分享社区
01-03 8947
转载注明出处:http://blog.csdn.net/qxuewei/article/details/53945445 因为OC 的局限性, 使得iOS 开发组件化编程变得不可能,得益于面向对象语言的特性 (封装,继承,多态) 在我们熟悉的设计模式中渐渐形成统一的软件开发思想. 在抽取某些功能作为基类的不断运用中,代码的可移植性逐渐减弱. 就如同一棵树,从主干到各个分支,每个分支再长成细枝
IOS 工厂模式的面向协议编程思想
weixin_33694172的博客
05-18 188
2019独角兽企业重金招聘Python工程师标准>>> ...
面向协议编程与 Cocoa 的邂逅（上）
历史上的今天
12-01 730
作者简介： 王巍（@onevcat），江湖人称“喵神”，iOS 和 Unity3D 开发者，旅居日本，目前供职于 LINE，著有《Swifter - 100 个 Swift 必备 tips》，同时也是翻译项目 ObjC 中国的组织者和管理者，维护 VVDocumenter-Xcode 及 Kingfisher 等开源项目，博客地址：https://onevcat.com。 技术之路，我...
iOS 开发 第一章 类、结构体、mvc、面向协议编程
苏雅乐图的博客
04-22 439
一、类和结构体      类是现实生活中的物体的抽象，它可以将一个物体的属性、动作等封装在一个类里面。可以将这个类型继承给它的子类，可以拥有多个子类，但是只能有一个父类。     结构体的功能和类相似，但是有一个本质的区别那就是类是引用类型，结构体是值类型。引用类型和值类型最大的区别在于传递参数上，值类型在传递时传递的是原类型的拷贝，就是另外建立一个一摸一样的。改变传递的值不会涉及到原类型。而引用...
[转] iOS --- 基于面向协议MVP模式下的软件设计
icetime17的专栏
12-23 972
MVC是构建iOS App的标准模板。随着时间的推移，在iOS平台上MVC也逐渐开始面临着越来越多的问题,最近又开始流行MVVM,MVVM使由MVC衍生而来，MVVM作为一种新的开发模式和响应式编程相结合用来解决一部分业务场景等，今天，我要介绍给大家的是一个新的方式来架构你的App: Model-View-Protocol,暂时可以理解为是基于协议的一种设计规范,拿出你的流行语bingo card，因为我们即将进行一次范式转变。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值