1.通过扩展采纳协议

// 定义一个Animal协议
protocol Animal{
    
    var getName:String{get}
}

// 定义一个Dog类，但是没有采纳Animal协议
class Dog{
    
    func shout() -> String{
        return "汪汪汪"
    }
}

// 通过扩展采纳并实现Animal协议
extension Dog:Animal{
    
    var getName:String{
        
        return "泰迪"
    }
}

let dog = Dog()

print("狗的叫声\(dog.shout())")
print("狗的名字\(dog.getName)")

2.通过空扩展采纳协议

当一个类型已经符合了每个协议中的所有要求，却没有声明采纳该协议时，类型并不会自动采纳协议，此时，可以通过一个实现体为空的扩展（即空扩展）来采纳该协议

protocol Getname{
    
    var getName:String{get}
}

// 定义一个Student结构体
struct Student {
    
    var name:String
    var getName:String{
        return "这个学生的名字是\(name)"
    }
}

extension Student:Getname{}

let people = Student(name:"小明")
print(people.getName)
let student:Getname = people
print(student.getName)

3.协议的扩展

protocol People{
    
    func drink() -> String
}

// 扩展新增方法并实现，此时必须实现
extension People{
    
    func eat() -> String {
        
        return "吃骨头"
    }
    func legs() -> Int {
        
        return 2
    }
}

class Teacher: People {
    
    func drink() -> String {
        return "喝水"
    }
}

let teacher = Teacher()
print(teacher.drink())
print(teacher.eat())
print("人类\(teacher.legs())条腿")