swift 12.2 协议分类、代理

1协议分类

1.协议中定义的方法使用mutating修饰

类遵守协议 实现协议中使用mutating修饰的方法的时候，可以将mutating去掉

protocol MyProtocol {
    mutating func test(arg: Int)
}

struct Point: MyProtocol {
    var x: Int
    var y: Int
    
    init(x: Int, y: Int){
        self.x = x
        self.y = y
    }
    mutating func test(arg: Int) {
        x += arg
    }
}

class Size: MyProtocol {
    var width: Int = 0
    
    func test(arg: Int) {
        width += arg
    }
}

2.合成协议:

(1)将多个协议放在一起组成一个新的临时类型，使用合成协议类型定义常量、函数形参、函数的返回值
(2)定义成合成协议类型的变量，必须遵守所有的协议，实现所有协议中的方法

/* 格式：
protocol <协议1，协议2...>
*/

protocol iOSCoder {
    func write()
    func debug()
}

protocol Company {
    func work()
}

class Student: iOSCoder,Company {
    func write() {
        print("写代码")
    }
    
    func debug() {
        print("调bug")
    }
    
    func work() {
        print("工作")
    }
}
    func test(arg: protocol) -> Void {
        arg.debug()
        arg.work()
        arg.write()
}

test(Student())

3.唯类协议：

只有类才能实现协议中的内容，其它类型（枚举、结构体）不能实现协议中的内容

屏幕快照 2016-08-17 下午6.35.46.png

//格式: protocol 协议名称: class,父协议1，父协议2...
protocol Test: class{
    func move()
}


//struct Car: Test {
//    func move() {
//        print("pao")
//    }
//}

class Bus: Test {
    func move() {
        print("pao")
    }
}

4.可选协议 :

(1)可选协议中定义的内容可以实现也可以不实现，在内容前面添加关键字optional

(2)swift的协议是完全兼容OC协议的，而optional是OC协议中的关键字，所以可选协议是OC协议类型，在协议前添加@objc(如图)

屏幕快照 2016-08-17 下午6.43.08.png

【注意1】swift中使用协议定义的变量，不是AnyObject类型，只是一个普通的变量
【注意2】转为OC的协议,定义的变量就是遵守协议的AnyObject

(3)可选协议也是唯类协议

@objc protocol LWY {
    optional func fly()
    optional func run()
}

class Person: LWY {
    
    //可以选择实现上面的内容
}

//可选协议也是唯类协议

//struct Man: LWY {
//    <#fields#>
//}

2代理

1简介

(1)主动方向被动方传值成为正向传值
被动方向主动方传值称为反向传值
/*
1、主动方制定协议
2、被动方遵守协议 实现协议中的方法
3、主动方设置遵守协议的代理 主动方.delegate = 被动方
*/

(2)委托与代理
A想完成一件事 A不能完成 委托B帮忙完成 那么B就是A的代理

2传值

(3)协议关联，代理传值(代码如下)

//定义协议 将人类的需求放在协议中 谁能遵守协议实现人类的需求 就能成为人类的代理
protocol AnimalBark {
    func bark(count: Int)
}

class Dog: AnimalBark {
    var name: String
    init(name: String) {
        self.name = name
    }
    func bark(count: Int) -> Void {
        print("旺旺\(count)声")
    }
}
class Cat: AnimalBark {
    func bark(count: Int) -> Void {
        print("喵喵\(count)声")
    }
}

class Person {
    var name: String = ""
    //var dog: Dog?
    //var cat: Cat?
    
    //任何类的对象都能成为代理 前提是类的对象必须遵守协议
    var delegate: AnimalBark?
    
    func tell(num: Int) -> Void {
//        print("\(name)委托\(dog!.name)出去叫两声")
//        dog?.bark()
        
        print("\(name)委托delegate出去叫\(num)声")
        delegate!.bark(num)
    }
}
let person = Person.init()
person.name = "小新"
let dog = Dog.init(name: "小白")
//已经成为人的代理
//person.dog = dog

let tom = Cat.init()
//成为人的代理
person.delegate = dog
person.tell(100)

person.delegate = tom
person.tell(10)