swift基础之协议

原创 2016年05月30日 13:34:47

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



版权声明:与大家一同进步

OC转Swift之基础篇(四)--协议&扩展

Swift协议&扩展

swift3新路程(10)协议protocol和扩展extension

声明的关键字就是protocol 我们看一个官方例子 protocol ExampleProtocol { var simpleDescription: String { get } ...

swift delegate 协议 代理

  • 2015年07月10日 17:24
  • 60KB
  • 下载

swift函数式编程(高级)-闭包,协议,扩展,泛型,可空链

swift函数式编程实际是非常灵活的,在函数的高级应用中,实际上还包括了闭包,协议,泛型等等oc中没有的概念,按照顺序介绍这些概念和应用。 一:闭包 闭包实际就是objective-c中的bloc...

《Swift 的界面之间的传值,详细介绍3种传值方式》 正向传值、协议传值、闭包

《Swift 的界面之间的传值,详细介绍3种传值方式》正向传值、协议传值、闭包    1、 控制器界面间的正向传值    /*    《Swift 的界面之间的传值,详...

swift详解之十一------------协议、委托(代理)模式

协议、委托(代理)模式注:本小节总结协议以及依靠协议实现委托,这将在以后经常被使用。是一个非常重要的模块看下官方的定义:协议定义了一个蓝图 , 规定了用来实现某一特定工作或者功能所必须的方法和属性,类...

利用Swift之协议语法实现页面间的传值功能

利用Swift之协议语法实现页面间的传值功能
  • mapboo
  • mapboo
  • 2014年09月28日 17:12
  • 6604
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:swift基础之协议
举报原因:
原因补充:

(最多只允许输入30个字)