Protocol

/* Protocol 协议与C++中的Interface有啥区别。。。

1.协议为类，枚举，结构体等遵循者定义了一套蓝图，

该蓝图包括方法（实例，Type方法），属性，operator和subscripts等具体的样子。

这些遵循者遵循者在具体的实现中必须实现协议中规定的属性或者方法。

2.类不可以多继承，但是协议可以多继承，继承父类需要放在前面，多个用逗号隔开

class someClass: SuperClass, FirstProtocol, SecondProtocol

{ }

3.协议可以作为类型使用，函数参数，返回值，变量，数组，字典等的类型修饰符，都可以使用。

4.协议本身不可以被扩展，但是别的类型，类或者结构体进行扩展时，

可以将添加Protocol作为扩展项目

5.多个协议可以临时组合成一个大的协议用，通过 potocol<协议1,协议2>的语法。

6.再协议定义的时候前面加上@objc，就可以通过as,as?,is来检查某个实例是否遵循某协议

注意只要加上@objc的类的实例，不管类型与OC是否有关，都只能类才可以继承

7.可以为协议添加Optional的方法或属性，这样继承的类就可以选择性实现该方法或属性

注意只有前面加上@objc的协议才可以定义optional成员

*/

protocol MyProtocol

{

    //1.协议可以要求其遵循者提供一个特定得属性名或者特定得类型

    //协议不能指定该属性事stored得还是computed，但是可以指定其读写属性

    //关于TypeProperty，不管是结构体还是类都适用class关键字

   var mustBeSettable:Int { get set }//✨✨注意get和set之间仅仅是个空格

   var doesNotNeedToBeSettable:Int { get }//由于协议只指定可读，是否可写没有指定

    

   class var myTypeProperty:Int { get set }

    

    //2.协议可以指定函数，参数包括可变参数，协议中的函数不能有大括号及里面的实现体

    //协议中不可以给参数提供默认值

    //type method不管是类的还是结构体用的，协议都用class

    //类中的函数修改属性时不需要mutating，但是如果想作为struct，枚举用的时候需要用mutating

   mutating func commonMethod(para:Int)->Int

   class func myTypeMethod()

}

class MyClass:MyProtocol

{

   var mustBeSettable:Int = 3

   var doesNotNeedToBeSettable = 3//这个可以设置为只读的也可以设置为读写的。

    

   classvar myTypeProperty:Int//类暂时不支持Stored的静态变量

    {

       get

        {

           return 1

        }

       set

        {

           //nothing

        }

    }

    

    //类的话就不需要mutating修饰了

   func commonMethod(testPara:Int)->Int

    {

       mustBeSettable = testPara

       return 1

    }

    

   class func myTypeMethod()

    {

        println("Type Method")

    }

}

// 协议作为类型用

var myProtocolVar: MyProtocol = MyClass()

protocol SmallPro

{

   func test()

}

//将MyClass扩展为SmallPro协议的遵循者

extension MyClass : SmallPro

{

   func test()

    {

        println("ExtensionProtocol")

    }

}

//如果一个类实现了协议的所有的方法和属性，但是没有显示的继承的话就没有从属关系

//这时可以继承一个协议，实现体为空即可

//extension MyClass : SmallPro {}

// 协议数组的例子

class Test1: SmallPro

{

   func test()

    {

        println("I'm Test1")

    }

}

//用此方法可以很容易的实现设计模式中的代理模式

class Test2: SmallPro

{

   func test()

    {

        println("I'm Test2")

    }

}

var protocolArray:[SmallPro] = [Test1(),Test2()]

for item inprotocolArray

{

    item.test()

}

//5.多个协议可以临时组合成一个大的协议用，通过 protocol<协议1,协议2>的形式

//如下定义，函数的参数是一个类型，这个类型必须要同时继承了Age和Name的类型

//func wishHappyBirthday(celebrator:protocol<Age, Name>)

//6.Checking for Protocol Conformance-------------------------

@objc protocol HasArea{//注意，必须有@objc才可以进行是否遵循协议的check

   var area:Double {get }

}

class Squre:HasArea {

   var length = 3.0

   var area:Double {

   get {

       returnself.length *self.length

    }

    }

}

class Country:HasArea {

   var area:Double = 3.0

}

//前面章节说过可以通过AnyObject代替任何的类型

var myNewArray:[AnyObject] = [Squre(),Country(),MyClass()]

for item in myNewArray//注意必须继承了HasArea的协议,只能是类,并且该协议前加@objc

{

   ifvar tmpobj = item as? HasArea

    {

        println("I'm the subclass of HasArea and area is:\(tmpobj.area)")

    }

   else

    {

        println("I'm not the subclass of HasArea")

    }

}