2020-04-22

引入

协议定义了一个大致的框架，规定里面有哪些属性和方法，至于这个属性的值是多少或者方法怎么实现，留给别人实现。——就像java里接口。

协议的定义

```

protocol SomeProtocol {

    // 属性

    // 方法

}

```

属性定义要求

1、不能用默认值

2、必须指明类型： { set get } 来表示属性是可读可写的，可读属性则用 { get }

3、必须用var修饰

方法定义要求

1、方法不能有方法体

2、方法不可以有默认值

```

//【协议的定义】——错误示范

protocol Pet{

    var name:String = "tets"

    var age:Int = 18

    func feed(food:String){}

}

//【协议的定义】——正确示范

protocol Pet{

    var name:String{get set}

    var age:Int{get}

    func feed(food:String)

    func shout(sound:String)

}

```

协议的遵循

协议写好了，要有人来遵守，怎么遵守呢？

语法

```

class 类：父类,协议1,协议2{

}

含义：类继承某个父类，同时我遵守协议1和2

```

实现协议中的属性

1、属性可以设置默认值

2、协议中属性为可读可写，必须声明为var

3、协议中属性为可读的，实现中可以声明let或者var

实现协议中的方法

1、方法中的参数可以传默认值

```

//协议的定义

protocol Pet{

    var name:String{get set}

    var age:Int{get}

    func feed(food:String)

    func shout(sound:String)

}

//【协议的遵守】

class Cat:Pet{

    //属性可以设置默认值

    //可读可写用var

    var name: String = "mimi"

    //只读可以用let

    let age: Int = 10

    func feed(food: String) {

        print("feed\(food)")

    }

    //方法参数可以有默认值

    func shout(sound: String = "miaomiao") {     

        print("shout\(sound)")

    }

}

```

协议的继承

```

//【协议的继承】

protocol Protocol1{

    func playBasketball()

    func playFootball()

}

//让第二个协议去继承第一个协议,相当于3个协议

protocol Protocol2:Protocol1{

    func studyJava()

}

//【提问】 实现几个方法？ 实现协议中的所有方法

class Student:Protocol2{

    func studyJava() {

        <#code#>

    }

   

    func playBasketball() {

        <#code#>

    }   

    func playFootball() {

        <#code#>

    }

}

```

协议中方法可选

如何实现让协议中有些方法有些可以有选择性的实现？

【方案一】 optional

在方法前添加@objc optional;在协议前用@objc修饰——不建议，建议用另一种方式，后面学

注意：@objc实在foundation框架中，如果注释掉import 会报错

```

@objc protocol Protocol1{

    @objc optional func playBasketball()

    func playFootball()

}

class Student:Protocol1{

    func playFootball() {

        <#code#>

    }

}

```

协议的运用

iOS开后后面经常会用到，代理模式的基础就是协议。

现实生活中代理模式很常见，比如我们想干一件事，但是这件事不是我们的专长，所以会委托别人来帮忙。

比如租房子，你不会在小区里挨个问谁有房子出租，我们回去找中介。

A-----目标 搞不定

A---B->完成目标， A委托B，B就是我们说的代理。

注意： 代理不是想当就当的，需要满足某些条件。

```

protocol BuyTicketProtocol{//凡是实现这个协议的人，我都可以让他帮我买票

    func buyTicket()

}

class MiShu:BuyTicketProtocol{

    func buyTicket() {

        print("秘书买票")

    }

}

class HuangNiu:BuyTicketProtocol{

    func buyTicket() {

        print("黄牛买票")

    }

}

class Boss{

    var delegate:BuyTicketProtocol  //找一个能买票的人，【思考】应该是什么类型？

    init(delegate:BuyTicketProtocol) {

        self.delegate = delegate

    }

    func gotoBJ(){

        //买票

        delegate.buyTicket()

        print("票到手，去出差")

    }

}

var boss = Boss(delegate: HuangNiu())

boss.gotoBJ()

boss = Boss(delegate:MiShu())

boss.gotoBJ()

```