使用protolcol 来定义一个协议。

protocol ExampleProtocol {
    var simpleDescription: String {get}
    mutating func adjust()
}

类、枚举和结构体都可以使用协议。

class SimpleClass: ExampleProtocol {
    var simpleDescription: String = "A very simple class."
    var anotherProperty: Int = 69105
    func adjust() {
        simpleDescription += " Now 100% adjusted."
    }
    
}
var a = SimpleClass()
a.adjust()
let aDescription = a.simpleDescription

struct SimpleStructure:ExampleProtocol {
    var simpleDescription: String = "A simple structure."
    mutating func adjust() {
        simpleDescription += " (adjusted)"
    }
}
var b = SimpleStructure()
b.adjust()
let bDescription = b.simpleDescription

练习：写一个枚举遵循这个协议。

enum SimpleEnumeration: ExampleProtocol {
    case Enum1(String), Enum2(String), Enum3(String)
    var simpleDescription: String {
        get {
            switch self {
            case let .Enum1(text), let .Enum2(text), let .Enum3(text):
                return text

            }
        }
        set {
            switch self {
            case let .Enum1(newValue):
                self = .Enum1(newValue)
            case let .Enum2(newValue):
                self = .Enum2(newValue)
            case let .Enum3(newValue):
                self = .Enum3(newValue)
            }
        }
    }
    
    mutating func adjust() {
        switch self {
        case let .Enum1(text):
            self = .Enum1(text + " enum1 case adjusted.")
             text + " enum1 case adjusted."
        case let .Enum2(text):
            self = .Enum2(text + " enum2 case adjusted.")
        case let .Enum3(text):
            self = .Enum3(text + " enum1 case adjusted.")
        }
    }
}

var simpleEnum = SimpleEnumeration.Enum1("One")
simpleEnum.simpleDescription
simpleEnum.adjust()
simpleEnum.simpleDescription

var simpleEnum2 = SimpleEnumeration.Enum2("Two")
var texts = simpleEnum2.simpleDescription
simpleEnum2.simpleDescription = "Hello"
texts = simpleEnum2.simpleDescription
simpleEnum2.adjust()
texts = simpleEnum2.simpleDescription

simpleEnum2 = SimpleEnumeration.Enum2("second")
simpleEnum2.simpleDescription
simpleEnum2.adjust()

simpleEnum2 = SimpleEnumeration.Enum1("first")

注意在SimpleStructure中mutating关键词的使用，用来标记一个可以修改结构体的方法。声明SimpleClass时则不需要标记任何方法为mutating，因为类中的方法都可以对类进行修改。

使用扩展（extension）来为已有的类型添加功能，比如新的方法和计算属性。你可以使用扩展来为类型（这个类型甚至可以来源于导入的其它的库和框架）添加协议。

extension Int: ExampleProtocol {
    var simpleDescription: String {
        return "The number of \(self)"
    }
    
    mutating func adjust() {
        self  += 42
    }
}
print(7.simpleDescription)
var number = 2
number.adjust()
//2.adjust()

练习：为 Double 类型写一个扩展用来添加一个 absoluteValue 属性。

extension Double {
    var absoluteValue: Double {
        return 10.0
    }
//    var absoluteValue: String {
//        return "Double"
//    }
    
}

你可以像其它命名类型一样使用协议名。例如，创建一个不同类型对象集合，但是全部遵循一个单独的协议。当你处理一个类型为protocol的值时，协议外部的方法将无法访问。

var simpleClass = SimpleClass()
var protocolNumber = 10
var protocolValue: ExampleProtocol = simpleClass
print(protocolValue.simpleDescription)
//print(protocolValue.anotherProperty)  //取消注释可以看到报错
protocolValue.adjust()


let protocolValue1: ExampleProtocol = protocolNumber
print(protocolValue1.simpleDescription)

虽然protocolValue变量的运行时类型是SimpleClass，但是编译器还是会把它当做ExampleProtocol类型来处理。这表示你无法访问协议规定之外的类的属性或者方法。