Swift教程之代理协议

原创 2015年07月10日 11:42:50
import Foundation

//协议的语法

//MARK: - 1、协议的定义
protocol FirstProtocol
{
    // 协议内容
}
protocol AnotherProtocol
{
    // 协议内容
}



//MARK: - 2、实现协议
//在类型名称后加上协议名称,中间以冒号:分隔即可实现协议;实现多个协议时,各协议之间用逗号,分隔
struct SomeStructure: FirstProtocol, AnotherProtocol
{
    // 结构体内容
}

//如果一个类在含有父类的同时也采用了协议,应当把父类放在所有的协议之前:
class SomeSuperClass{}
class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol
{
    // 类的内容
}


//MARK: - 3、对属性的规定
//协议中的属性经常被加以var前缀声明其为变量属性,在声明后加上{ set get }来表示属性是可读写的,只读的属性则写作{ get }
protocol SomeProtocol
{
    var mustBeSettable : Int { get set }
    var doesNotNeedToBeSettable: Int { get }
    //通常在协议的定义中使用class前缀表示该属性为类成员;在枚举和结构体实现协议时中,需要使用static关键字作为前缀。
    static var someTypeProperty: Int { get set }
}

//demo
protocol FullyNamed
{
    var fullName: String { get }
}
struct Person: FullyNamed
{
    var fullName: String
}

let john = Person(fullName: "John Appleseed")
class Starship: FullyNamed
{
    var prefix: String?
    var name: String
    init(name: String, prefix: String? = nil )
    {
        self.name = name
        self.prefix = prefix
    }
    var fullName: String
    {
        return (prefix != nil ? prefix! + " " : " ") + name
    }
}
var ncc1701 = Starship(name: "Enterprise", prefix: "USS")
// ncc1701.fullName == "USS Enterprise"

//MARK: - 4、对方法的规定
protocol RandomNumber
{
    func random() -> Double
}
class LinearCongruentialGenerator: RandomNumber
{
    var lastRandom = 42.0
    let m = 139968.0
    let a = 3877.0
    let c = 29573.0
    func random() -> Double
    {
        lastRandom = ((lastRandom * a + c) % m)
        return lastRandom / m
    }
}
let generator = LinearCongruentialGenerator()
print("随机数1: \(generator.random())")
// 输出 : "随机数1: 0.37464991998171"
print("随机数2: \(generator.random())")
// 输出 : "随机数2: 0.729023776863283"

//4.1、对变异方法的规定
protocol Togglable
{
    mutating func toggle()
}
enum OnOffSwitch: Togglable
{
    case Off, On
        mutating func toggle()
        {
            switch self
            {
                case Off:
                    self = On
                case On:
                    self = Off
            }
        }
}
var lightSwitch = OnOffSwitch.Off
lightSwitch.toggle()
//lightSwitch 现在的值为 .On


//MARK: - 5、对构造器的规定
protocol SProtocol
{
    init()
}


class SSuperClass
{
    init() {
        //协议定义
    }
}


class SSubClass: SSuperClass, SProtocol
{
    // "required" from SomeProtocol conformance; "override" from SomeSuperClass
    //使用required修饰符可以保证:所有的遵循该协议的子类,同样能为构造器规定提供一个显式的实现或继承实现。
    required override init()
    {
        // 构造器实现
    }
}

//MARK: - 6、协议类型
/*
尽管协议本身并不实现任何功能,但是协议可以被当做类型来使用。
使用场景:
协议类型作为函数、方法或构造器中的参数类型或返回值类型
协议类型作为常量、变量或属性的类型
协议类型作为数组、字典或其他容器中的元素类型
*/
class Dice
{
    let sides: Int
    let generator: RandomNumber
    init(sides: Int, generator: RandomNumber)
    {
        self.sides = sides
        self.generator = generator
    }
    func roll() -> Int
    {
        return Int(generator.random() * Double(sides)) + 1
    }
}
var d6 = Dice(sides: 6,generator: LinearCongruentialGenerator())
for _ in 1...5
{
    print("Random dice roll is \(d6.roll())")
}
//输出结果
//Random dice roll is 3
//Random dice roll is 5
//Random dice roll is 4
//Random dice roll is 5
//Random dice roll is 4


//MARK: - 7、在扩展中添加协议成员
protocol TextRepresentable
{
    func asText() -> String
}
extension Dice: TextRepresentable
{
    func asText() -> String
    {
        return "A \(sides)-sided dice"
    }
}
let d12 = Dice(sides: 12,generator: LinearCongruentialGenerator())
print(d12.asText())
// 输出 "A 12-sided dice"


//MARK: - 8、通过扩展补充协议声明
struct Hamster
{
    var name: String
    func asText() -> String
    {
        return "A hamster named \(name)"
    }
}
extension Hamster: TextRepresentable {}
let simonTheHamster = Hamster(name: "Simon")
let somethingTextRepresentable: TextRepresentable = simonTheHamster
print(somethingTextRepresentable.asText())
// 输出 "A hamster named Simon"


//MARK: - 9、集合中的协议类型
//协议类型可以被集合使用,表示集合中的元素均为协议类型
let things: [TextRepresentable] = [d12, simonTheHamster]
for thing in things
{
    print(thing.asText())
}
// A 12-sided dice
// A hamster named Simon

//MARK: - 10、协议的继承
//协议能够继承一到多个其他协议。语法与类的继承相似,多个协议间用逗号,分隔
protocol InheritingProtocol: SomeProtocol, AnotherProtocol
{
    // 协议定义
}

//MARK: - 11、类专属协议
//你可以在协议的继承列表中,通过添加“class”关键字,限制协议只能适配到类(class)类型。(结构体或枚举不能遵循该协议)。该“class”关键字必须是第一个出现在协议的继承列表中,其后,才是其他继承协议。
//协议SomeClassOnlyProtocol只能被类(class)类型适配。如果尝试让结构体或枚举类型适配该协议,则会出现编译错误。
protocol SomeClassOnlyProtocol: class, SomeProtocol, AnotherProtocol
{
    // class-only protocol definition goes here
}

//MARK: - 12、协议合成
//一个协议可由多个协议采用protocol<SomeProtocol, AnotherProtocol>这样的格式进行组合,称为协议合成(protocol composition)。
//协议合成并不会生成一个新协议类型,而是将多个协议合成为一个临时的协议,超出范围后立即失效。
protocol Named
{
    var name: String { get }
}
protocol Aged
{
    var age: Int { get }
}
struct User: Named, Aged
{
    var name: String
    var age: Int
}
func wishHappyBirthday(celebrator: protocol<Named, Aged>)
{
    print("生日快乐,\(celebrator.name) - 你\(celebrator.age)啦!")
}
let birthdayPerson = User(name: "小明", age: 21)
wishHappyBirthday(birthdayPerson)
// 输出 "Happy birthday Malcolm - you're 21!

//MARK: - 13、检验协议的一致性
/*
is操作符用来检查实例是否遵循了某个协议。
as?返回一个可选值,当实例遵循协议时,返回该协议类型;否则返回nil
as用以强制向下转型。
@objc用来表示协议是可选的,也可以用来表示暴露给Objective-C的代码,此外,@objc型协议只对类有效,因此只能在类中检查协议的一致性
*/
@objc protocol HasArea
{
    var area: Double { get }
}
class Circle: HasArea
{
    let pi = 3.1415927
    var radius: Double
    @objc var area: Double
    {
        return pi * radius * radius
    }
    init(radius: Double)
    {
        self.radius = radius
    }
}
class Country: HasArea
{
    @objc var area: Double
    init(area: Double)
    {
        self.area = area
    }
}
class Animal
{
    var legs: Int
    init(legs: Int)
    {
        self.legs = legs
    }
}
let objects: [AnyObject] = [
    Circle(radius: 2.0),
    Country(area: 243_610),
    Animal(legs: 4)]
for object in objects
{
    if let objectWithArea = object as? HasArea
    {
        print("面积是\(objectWithArea.area)")
    } else {
        print("有些没面积")
    }
}
// Area is 12.5663708
// Area is 243610.0
// Something that doesn't have an area


//MARK: - 14、对可选协议的规定
//可选协议含有可选成员,其遵循者可以选择是否实现这些成员。在协议中使用optional关键字作为前缀来定义可选成员。
//注意: 可选协议只能在含有@objc前缀的协议中生效。且@objc的协议只能被类遵循
@objc protocol CounterDataSource
{
    optional func incrementForCount(count: Int) -> Int
    optional var fixedIncrement: Int { get }
}
@objc class Counter
{
    var count = 0
    var dataSource: CounterDataSource?
    func increment()
    {
        if let amount = dataSource?.incrementForCount?(count)
        {
            count += amount
        }
        else if let amount = dataSource?.fixedIncrement
        {
            count += amount
        }
    }
}
class ThreeSource: CounterDataSource
{
    @objc let fixedIncrement = 3
}
var counter = Counter()
counter.dataSource = ThreeSource()
for _ in 1...4
{
    counter.increment()
    print(counter.count)
}
// 3
// 6
// 9
// 12

版权声明:本文为博主原创文章,未经博主允许不得转载。

对照Java学习Swift--协议(Protocols)

简要协议是苹果给它自己设计的语言的一种类型,Swift和OC都叫协议,它的功能更Java中的接口非常类似,其实就是Java中的接口功能,就是名称不一样而已,我们可以类比来学,但是有一点,Java中没有...
  • lovexieyuan520
  • lovexieyuan520
  • 2016年05月14日 23:11
  • 1520

Swift 协议代理传值(十)

Objective-C这里演示反向传值SecondVC.h @protocol sendValueDelegate - (void)sendValueString:(NSString *)str; ...
  • sinat_30162391
  • sinat_30162391
  • 2016年04月01日 15:17
  • 904

小胖说swift07-------- swift协议代理的使用以及解决循环引用问题

这两天看了一下Swift的协议代理, 大体思路和OC没什么区别, 但是按照官方的书本写出的协议代理, 发现会有内存泄露问题, 找了半天没有发现问题, 突然想起看系统类的协议代理的写法, 瞬间发现了...
  • haogaoming123
  • haogaoming123
  • 2016年08月31日 18:05
  • 562

【Unity3D自学记录】Unity3D插件之EasyTouch简单用法

EasyTouch使用 EasyTouch 目录[-] 一、效果图二、操作步骤1.官方文档上的步骤2.翻译一下以上的步骤3.根据官方的这些提示,自己来做一个属于自己的人物遥感控制 ...
  • hackdjh
  • hackdjh
  • 2014年07月07日 11:25
  • 1183

iOS开发之swift与OC混编出现的坑,oc中不能对swift的代理进行调用,不能访问swift中的代理,swift中的回调方法

1. swift与oc混编译具体怎么实现,这儿我就不重复讲出了,网上有大把的人讲解。 2. 在swift与OC混编的编译环境下, oc类不能访问swift创建类中的代理? 解决方法如下: ...
  • zhonggaorong
  • zhonggaorong
  • 2016年06月03日 18:38
  • 3485

[swift实战入门]手把手教你编写2048(一)

苹果设备越来越普及,拿着个手机就想捣鼓点啥,于是乎就有了这个系列,会一步一步教大家学习swift编程,学会自己做一个自己的app,github地址:https://github.com/scarlet...
  • silk_bar
  • silk_bar
  • 2016年04月09日 23:17
  • 5895

Swift 委托/代理设计模式

Swift 中的委托/代理模式(一下简称"代理模式")基本一致。 代理设计模式的基本思想就是将我(类或者结构体等)需要来完成的工作交给(委托给)另一个有我所规定的做这项工作能力的人(符合要求类型的对象...
  • lwjok2007
  • lwjok2007
  • 2015年08月29日 15:06
  • 4057

VTK教程之十二&nbsp;可视化基础算法-几…

因为数量数据是
  • woashizhangsi
  • woashizhangsi
  • 2014年12月12日 09:41
  • 835

jQuery EasyUI使用教程之创建复杂的树网格

树网格可以展示有限空间上附带的多列和复杂数据电子表格。本教程将演示如何将表格数据排列在分割的网格和多行表头中,以便组织共同的数据。 jQuery EasyUI最新试用版下载请猛戳>> ...
  • AABBbaby
  • AABBbaby
  • 2016年07月20日 09:51
  • 403

VTK教程之十三&nbsp;可视化基础算法-位…

  位移图主要描
  • woashizhangsi
  • woashizhangsi
  • 2014年12月12日 09:38
  • 546
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Swift教程之代理协议
举报原因:
原因补充:

(最多只允许输入30个字)