swift基础之协议

swift基础之协议

分为：

一、协议初步

1、协议的定义

2、协议的语法

3、协议对属性，方法，构造器的规定

4、协议类型

二、协议进阶

1、利用协议实现代理模式

2、协议继承

3、类的专属协议

4、协议合成

5、协议检查

6、协议扩展

一、协议初步

1、协议的定义

协议类似于其他语言的接口，用来规定要实现的某些特定功能必须的属性和方法

类、结构体、枚举都可以实现协议规定的方法和属性 叫做遵循协议

使用方法：  冒号“ ： ”  协议的名字

遵循多个协议，用逗号“ , ” 隔开

2、语法

protocolSomeProtocol {

   //协议内容
   //规定的属性，方法、构造器

}

3、协议对属性，方法，构造器的规定

//协议对属性的规定

protocoloneProtocol {

   var canFly :Bool{get}//只读
   var name :String 
{get set}//读写
   var amplitude :Double{get set}

   var frequency :Double{get set}

} 

//协议对方法的规定

要求实现特定的实例方法或者类方法，不支持参数默认值

实例方法，

只需要指定函数名，参数，返回值 不需要括号

protocol FlyProtocol {

   func fly()//无参数，无返回值

   func speed() ->Double//无参数，有返回值

}

类型方法

相当于OC类方法 需要在方法名前加 static

protocol
SomeProtocol {

   
static func
Funtion(value:String) ->String
}

构造器  遵循构造器必须 使用 必须关键字 required 

protocol
SomeProtocol {

   
init(name:String)
}

protocol
someProtocol {

   
var name:String
{
get }    
//属性
   
var age :Int
{
getset
}

   
func fun(value:String) ->
String       
//实例方法
   
staticfunc
fun2(value:String) ->String//类型方法
   
init(name:String)                      
//构造器
}

实现协议

class
SomeClass:
someProtocol {

   
var
name:
String

   
var age:
Int

   

   
func fun(value:
String) ->
String {

       
return value +
name

    }

   
static func
fun2(value:
String) ->
String {

       
return value

    }

   
required init(name:
String) {

       
self.name
= name

       
self.age
=
0

    }
}

协议的类型

protocol
Protocol {

   

}
class
A:
Protocol {

}
class
B:
Protocol {

}
var
a =
A()
var
b =
B()
var
typeArray:[Protocol] = [a,b]
typeArray.dynamicType 
//Array<Protocol>.Type

for
item
intypeArray{

   

   
iflet
one = item
as?
A{

    }

   
elseiflet
two = item
as?
B{

    }
}

二、协议进阶

1、利用协议是吸纳代理模式

    实例中提供的功能，实际上是内部引用的其他实例实现的
可以用来实现 发送请求，写入数据可等 非常灵活

//定义协议
protocol
oneProtocol{

   

    func
nslog(value:String)

}
//实现协议
class
oneClassDelegate:
oneProtocol {
//B

    func
nslog(value:
String) {

        print("输出信息\(value)")

    }

}

//定义协议类型，调用代理协议的方法
class
MyClassMake {
//A

    var
delegate:oneProtocol?//一个类型协议
   

    func
logMessage(value:String) {

       
delegate?.nslog(value)

    }

}

var
myClassMake =
MyClassMake()
//实例类A
myClassMake.delegate
=
oneClassDelegate()
///类里面协议属性是一个继承协议的实例类B
myClassMake.logMessage("hello
world")
//A调用自身的方法，里面调用的是协议的方法

输出：
输出信息 hello world
//B类在其中就是协议的代理实现，A类就调用B类里面代理方法

2、协议继承

一个协议继承另一个协议，相当于定义了父协议中的属性和方法

protocol
fatherProtocol {

   
func fatherFunction(value:String)

}
protocol
sonProtocol :
fatherProtocol {

   
func sonFunction(value:String) ->
String
}
实现协议

class
useProtocol:
sonProtocol {

   
func fatherFunction(value:
String) {

       
print("value")

    }

   
func sonFunction(value:
String) ->
String
{

       
return 
"这个值"
+ value

    }
}

3、类的专属协议

   只用类才能实现的协议，在协议后面继承 关键字 class
表明这个协议就就表明只能有类去实现，使用结构体实现就会失败

protocol
classOnlyProtocol :
class,sonProtocol{

   

}
class
onlyClass:
classOnlyProtocol {

   
func fatherFunction(value:
String) {

       
print(value)

    }

   
func sonFunction(value:
String) ->
String
{

       
return value

    }
}

4、协议的合成 

协议的合成并不会生成一个新的类型，而是将多个协议合成一个临时的协议，超出范围就会立即失效

var
dsadsa :
protocol<oneProtocol,twoProtocol>
这就是一个合成的临时的协议

protocol
oneProtocol {

   
var topSpeed:Int
{
get  }

}
protocol
twoProtocol {

   
var maxSpeed:Int
{
get }

}
struct
MyCar:oneProtocol,twoProtocol
{

   
var topSpeed:
Int =
30

   
var maxSpeed:
Int =
50

}

这个函数里面的参数就是一个合成的临时协议
func
testComponseProtocol(type:
protocol<oneProtocol,twoProtocol>)
{

   
print(type.topSpeed,type.maxSpeed)

}
var
myCar =
MyCar()
testComponseProtocol(myCar)   
输出：
30 50

5、协议检查

使用 is  检查类型返回bool值 当然也能检查是否遵循某个协议
myCar is oneProtocol

结果返回true,因为它继承了oneProtocol

6、协议扩展

使用协议扩展的方式可以为遵循者提供方法或者属性的实现
通过这个方式可以让我们无需每个遵循者都实现一次，无需使用全局函数
a、还可以为扩展提供一个默认的实现，
b、为协议的扩展添加限制条件
 
扩展的语法
使用 关键字where ，Self  注意不是self，首字母大写，里面函数实现使用
self

protocol
oneProtocol {

    var topSpeed:Int
{ get  }

}
protocol twoProtocol {

    var maxSpeed:Int
{ get
}

}

//添加默认的实现
extension
oneProtocol{ //扩展协议 提供了一个默认的属性实现 

    var topSpeed:Int
{

        get {

            return 20

        }

    }

}
extension
twoProtocol{ //扩展协议 提供了一个默认属性的实现

    var maxSpeed:
Int {

        return
60

    }

}
//添加一个限制条件
使用 关键字where ，Self  注意不是self，首字母大写，里面函数实现使用 self

extension oneProtocol where Self
:twoProtocol{

   
func
isSpeedBigger() ->
Bool {

       
return self.maxSpeed
>
self.topSpeed

    }
}

struct
MyCar:oneProtocol,twoProtocol
{//不用实现协议中属性，因为扩展协议提供了一个默认的属性实现

}

func testComponseProtocol(type:
protocol<oneProtocol,twoProtocol>) {

    print(type.topSpeed,type.maxSpeed)

}
var myCar =
MyCar()
testComponseProtocol(myCar)

输出： 20 60

myCar.maxSpeed
//60
myCar.topSpeed
//20
myCar.isSpeedBigger()
//true