把oc的协议和swift对比一下你就会发现swift的协议功能很强大，不过现在我也只是略懂一点点，现在把自己对协议的一点点理解贴出来，这里只讨论类型的协议，不讨论结构体和枚举的协议，举一反三，了解类型的协议之后其他的应该学起来也很快。  

 

声明协议协议里面声明了一个方法和一个属性  

 


@objc protocol SonOneProtocol {
     //声明一个协议方法
     func change(a:Int) -> Int
     //声明一个属性(get可读，set可写)
   @objc optional var age:Int {get set}
 } 
  
 创建个类SonOne，类里面声明了一个代理，后面会用到 
  
class SonOne: Person {
 var oneName = "我是son1"
     //在sonone类中添加一个sonOneProtocol协议类型的属性
     var delegate:SonOneProtocol?
     func callChange()  {
         //调用协议
       self.delegate?.change(a:100)
     }
 } 
  
 //导入协议，让viewcontroller遵守这个协议,VC里面添加了按钮用来触发协议的，也可以用其他方式出发，根据各自情况而定 
  
class ViewController: UIViewController,SonOneProtocol{
 //override 重写父类方法需要写加此标记
     override func viewDidLoad() {
         super.viewDidLoad()
         self.view.backgroundColor = UIColor.white
         //添加一个button
         let button = UIButton()
         button.frame = CGRect.init(x: 100, y: 200, width: 200, height: 50)
         button.backgroundColor = UIColor.gray
         button.setTitle("我是一个button", for: UIControlState.normal)
         button.addTarget(self, action:#selector(buttonAction(_:)), for: .touchUpInside)
         self.view.addSubview(button)
         //初始化
         pers1 = SonOne()
         pers1?.delegate = self
     }
     func buttonAction(_ button:UIButton) {
         print("点击了按钮");
         //点击按钮的时候调用协议
         pers1?.callChange()
         pers1?.extenCallChange()
     }
     //实现协议方法
     func change(a:Int) -> Int {
         str = "我在协议方法里更改了属性值"
         print(str!);
         return a
     }
     //实现协议的属性
     var age = 200;
 }
 
  
到这里基本协议就是这样的，和oc对比差不多，用法是按照oc的用法，
 接下来还有 
  
协议的继承 
  
 协议可以继承，oc中的协议也是可以继承的， 
  
 接下来 
  
@objc protocol SonTwoProtocol:SonOneProtocol{
     //添加继承方法
    @objc optional func extenChangge()
 } 
  
 这样就可以了，使用起来和正常协议一样使用即可 
  
注意！！！有这种情况怎么办？ 
  
 有这种情况怎么办？ 
  
 如果某个类遵守两个协议，但是这两个协议有两个方法名一样的方法怎么办 
  
 //协议1 
  
@objc protocol SonOneProtocol {
     //声明一个协议方法
     func change(a:Int) -> Int
     //声明一个属性(get可读，set可写)
   @objc optional var age:Int {get set}
 }
 //协议2
 protocol SonThreeProtocol {
     func change(b:String) -> String
 } 
  
 这个两个协议有两个方法名一样的方法 
  
 让一个类遵守这个两个协议 
  
class SonOne: SonOneProtocol, SonThreeProtocol {
   func change(b:String) -> String{return b}
    func change(a:Int) -> Int{return a}
 } 
  
 我们调用的时候就不知道是哪个方法怎么办？ 
  
 可以这样解决 
  
 let p1 = SonOne() 
  
 let num = (p1 as SonOneProtocol). change(a：100) 
  
 let string = (p1 as SonThreeProtocol). change(b："100") 
  

类型扩展 
  
 类型的扩展和添加计算型属性，方法等等 
  
 很方便， 
  
 接下来介绍扩展一个类型并且遵守一个协议 
  
 简单看下 
  
 //类的扩展 
  
extension SonOne{
     //添加属性
     var extenName:String { return "我是扩展后的属性"}
     //添加方法
     func extenCallChange()  {
         print("extenCallChange")
     }
 } 
  

 //类的扩展，并且遵守继承的协议，当遵守某个协议的时候要实现协议里面的方法 
  
extension SonOne:SonTwoProtocol{
     func change(a: Int) -> Int { return a }
     func extenChangge() {}
 }