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协议&扩展

思考 Swift 中的 MirrorType 协议

Swift中的反射非常有限,仅允许以只读方式访问元数据的类型子集。或许 Swift 因有严格的类型检验而不需要反射。编译时已知各种类型,便不再需要进行进一步检查或区分。然后大量的 Cocoa API ...

swift delegate 协议 代理

  • 2015-07-10 17:24
  • 60KB
  • 下载

Swift学习第七枪--协议(一)

协议(Protocols)协议 定义了一个蓝图,规定了用来实现某一特定工作或者功能所必需的方法和属性。类,结构体或枚举类型都可以遵循协议,并提供具体实现来完成协议定义的方法和功能。任意能够满足协议要求...

Swift 协议

Swift中的协议 在object-c也称之为协议,但是在其他语言中可能被称之为接口Interface(比如说java中)还有可能被称之为纯虚函数。实际上都是一个意思。 协议主要用来规定统一的方法和属...

对照Java学习Swift--协议(Protocols)

简要协议是苹果给它自己设计的语言的一种类型,Swift和OC都叫协议,它的功能更Java中的接口非常类似,其实就是Java中的接口功能,就是名称不一样而已,我们可以类比来学,但是有一点,Java中没有...

Swift的协议默认实现

继承和组合的缺点 带默认实现的协议 小结继承和组合的缺点在开发工作中,继承总是用来在多个类之间共享代码。 设想一个场景,一个人类,可以说话和睡觉,而一个Worker,除了上述功能,还可以工作。 解...
  • xsl_bj
  • xsl_bj
  • 2016-05-09 11:52
  • 2703

iOS --- 面向协议的编程(swift2.3)

iOS — 面向协议的编程(swift) 下面简单的介绍面向协议的编程的应用扩展协议和默认实现 面向协议编程 协议聚合 泛型约束 swift是面向协议的编程语言 UIKit中的委托模式 创建自己的...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

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